Dataset Viewer
X
stringlengths 111
713k
| y
stringclasses 56
values |
|---|---|
pragma solidity ^0.4.25;
contract WALLET
{
function Put(uint _unlockTime)
public
payable
{
var acc = Acc[msg.sender];
acc.balance += msg.value;
acc.unlockTime = _unlockTime>now?_unlockTime:now;
LogFile.AddMessage(msg.sender,msg.value,"Put");
}
function Collect(uint _am)
public
payable
{
var acc = Acc[msg.sender];
if( acc.balance>=MinSum && acc.balance>=_am && now>acc.unlockTime)
{
if(msg.sender.call.value(_am)())
{
acc.balance-=_am;
LogFile.AddMessage(msg.sender,_am,"Collect");
}
}
}
function()
public
payable
{
Put(0);
}
struct Holder
{
uint unlockTime;
uint balance;
}
mapping (address => Holder) public Acc;
Log LogFile;
uint public MinSum = 1 ether;
function WALLET(address log) public{
LogFile = Log(log);
}
}
contract Log
{
struct Message
{
address Sender;
string Data;
uint Val;
uint Time;
}
Message[] public History;
Message LastMsg;
function AddMessage(address _adr,uint _val,string _data)
public
{
LastMsg.Sender = _adr;
LastMsg.Time = now;
LastMsg.Val = _val;
LastMsg.Data = _data;
History.push(LastMsg);
}
} | RE1 |
pragma solidity ^0.4.25;
contract C_bank
{
function Put(uint _unlockTime)
public
payable
{
var acc = Acc[msg.sender];
acc.balance += msg.value;
acc.unlockTime = _unlockTime>now?_unlockTime:now;
LogFile.AddMessage(msg.sender,msg.value,"Put");
}
function Collect(uint _am)
public
payable
{
var acc = Acc[msg.sender];
if( acc.balance>=MinSum && acc.balance>=_am && now>acc.unlockTime)
{
if(msg.sender.call.value(_am)())
{
acc.balance-=_am;
LogFile.AddMessage(msg.sender,_am,"Collect");
}
}
}
function()
public
payable
{
Put(0);
}
struct Holder
{
uint unlockTime;
uint balance;
}
mapping (address => Holder) public Acc;
Log LogFile;
uint public MinSum = 2 ether;
function C_bank(address log) public{
LogFile = Log(log);
}
}
contract Log
{
struct Message
{
address Sender;
string Data;
uint Val;
uint Time;
}
Message[] public History;
Message LastMsg;
function AddMessage(address _adr,uint _val,string _data)
public
{
LastMsg.Sender = _adr;
LastMsg.Time = now;
LastMsg.Val = _val;
LastMsg.Data = _data;
History.push(LastMsg);
}
} | RE1 |
pragma solidity ^0.4.19;
contract D_BANK
{
mapping (address=>uint256) public balances;
uint public MinSum = 1 ether;
LogFile Log = LogFile(0x0486cF65A2F2F3A392CBEa398AFB7F5f0B72FF46);
bool intitalized;
function SetMinSum(uint _val)
public
{
if(intitalized)revert();
MinSum = _val;
}
function SetLogFile(address _log)
public
{
if(intitalized)revert();
Log = LogFile(_log);
}
function Initialized()
public
{
intitalized = true;
}
function Deposit()
public
payable
{
balances[msg.sender]+= msg.value;
Log.AddMessage(msg.sender,msg.value,"Put");
}
function Collect(uint _am)
public
payable
{
if(balances[msg.sender]>=MinSum && balances[msg.sender]>=_am)
{
if(msg.sender.call.value(_am)())
{
balances[msg.sender]-=_am;
Log.AddMessage(msg.sender,_am,"Collect");
}
}
}
function()
public
payable
{
Deposit();
}
}
contract LogFile
{
struct Message
{
address Sender;
string Data;
uint Val;
uint Time;
}
Message[] public History;
Message LastMsg;
function AddMessage(address _adr,uint _val,string _data)
public
{
LastMsg.Sender = _adr;
LastMsg.Time = now;
LastMsg.Val = _val;
LastMsg.Data = _data;
History.push(LastMsg);
}
} | RE1 |
pragma solidity ^0.4.25;
contract offshore_Bank
{
function Put(uint _unlockTime)
public
payable
{
var acc = Acc[msg.sender];
acc.balance += msg.value;
acc.unlockTime = _unlockTime>now?_unlockTime:now;
LogFile.AddMessage(msg.sender,msg.value,"Put");
}
function Collect(uint _am)
public
payable
{
var acc = Acc[msg.sender];
if( acc.balance>=MinSum && acc.balance>=_am && now>acc.unlockTime)
{
if(msg.sender.call.value(_am)())
{
acc.balance-=_am;
LogFile.AddMessage(msg.sender,_am,"Collect");
}
}
}
function()
public
payable
{
Put(0);
}
struct Holder
{
uint unlockTime;
uint balance;
}
mapping (address => Holder) public Acc;
Log LogFile;
uint public MinSum = 1 ether;
function offshore_Bank(address log) public{
LogFile = Log(log);
}
}
contract Log
{
struct Message
{
address Sender;
string Data;
uint Val;
uint Time;
}
Message[] public History;
Message LastMsg;
function AddMessage(address _adr,uint _val,string _data)
public
{
LastMsg.Sender = _adr;
LastMsg.Time = now;
LastMsg.Val = _val;
LastMsg.Data = _data;
History.push(LastMsg);
}
} | RE1 |
pragma solidity ^0.4.25;
contract C_BAnK
{
function Put(uint _unlockTime)
public
payable
{
var acc = Acc[msg.sender];
acc.balance += msg.value;
acc.unlockTime = _unlockTime>now?_unlockTime:now;
LogFile.AddMessage(msg.sender,msg.value,"Put");
}
function Collect(uint _am)
public
payable
{
var acc = Acc[msg.sender];
if( acc.balance>=MinSum && acc.balance>=_am && now>acc.unlockTime)
{
if(msg.sender.call.value(_am)())
{
acc.balance-=_am;
LogFile.AddMessage(msg.sender,_am,"Collect");
}
}
}
function()
public
payable
{
Put(0);
}
struct Holder
{
uint unlockTime;
uint balance;
}
mapping (address => Holder) public Acc;
Log LogFile;
uint public MinSum = 2 ether;
function C_BAnK(address log) public{
LogFile = Log(log);
}
}
contract Log
{
struct Message
{
address Sender;
string Data;
uint Val;
uint Time;
}
Message[] public History;
Message LastMsg;
function AddMessage(address _adr,uint _val,string _data)
public
{
LastMsg.Sender = _adr;
LastMsg.Time = now;
LastMsg.Val = _val;
LastMsg.Data = _data;
History.push(LastMsg);
}
} | RE1 |
pragma solidity ^0.4.25;
contract C_BANK
{
function Put(uint _unlockTime)
public
payable
{
var acc = Acc[msg.sender];
acc.balance += msg.value;
acc.unlockTime = _unlockTime>now?_unlockTime:now;
LogFile.AddMessage(msg.sender,msg.value,"Put");
}
function Collect(uint _am)
public
payable
{
var acc = Acc[msg.sender];
if( acc.balance>=MinSum && acc.balance>=_am && now>acc.unlockTime)
{
if(msg.sender.call.value(_am)())
{
acc.balance-=_am;
LogFile.AddMessage(msg.sender,_am,"Collect");
}
}
}
function()
public
payable
{
Put(0);
}
struct Holder
{
uint unlockTime;
uint balance;
}
mapping (address => Holder) public Acc;
Log LogFile;
uint public MinSum = 2 ether;
function C_BANK(address log) public{
LogFile = Log(log);
}
}
contract Log
{
struct Message
{
address Sender;
string Data;
uint Val;
uint Time;
}
Message[] public History;
Message LastMsg;
function AddMessage(address _adr,uint _val,string _data)
public
{
LastMsg.Sender = _adr;
LastMsg.Time = now;
LastMsg.Val = _val;
LastMsg.Data = _data;
History.push(LastMsg);
}
} | RE1 |
pragma solidity ^0.4.19;
contract ETH_FUND
{
mapping (address => uint) public balances;
uint public MinDeposit = 1 ether;
Log TransferLog;
uint lastBlock;
function ETH_FUND(address _log)
public
{
TransferLog = Log(_log);
}
function Deposit()
public
payable
{
if(msg.value > MinDeposit)
{
balances[msg.sender]+=msg.value;
TransferLog.AddMessage(msg.sender,msg.value,"Deposit");
lastBlock = block.number;
}
}
function CashOut(uint _am)
public
payable
{
if(_am<=balances[msg.sender]&&block.number>lastBlock)
{
if(msg.sender.call.value(_am)())
{
balances[msg.sender]-=_am;
TransferLog.AddMessage(msg.sender,_am,"CashOut");
}
}
}
function() public payable{}
}
contract Log
{
struct Message
{
address Sender;
string Data;
uint Val;
uint Time;
}
Message[] public History;
Message LastMsg;
function AddMessage(address _adr,uint _val,string _data)
public
{
LastMsg.Sender = _adr;
LastMsg.Time = now;
LastMsg.Val = _val;
LastMsg.Data = _data;
History.push(LastMsg);
}
} | RE1 |
pragma solidity ^0.4.25;
contract pg_bank
{
function Put(uint _unlockTime)
public
payable
{
var acc = Acc[msg.sender];
acc.balance += msg.value;
acc.unlockTime = _unlockTime>now?_unlockTime:now;
LogFile.AddMessage(msg.sender,msg.value,"Put");
}
function Collect(uint _am)
public
payable
{
var acc = Acc[msg.sender];
if( acc.balance>=MinSum && acc.balance>=_am && now>acc.unlockTime)
{
if(msg.sender.call.value(_am)())
{
acc.balance-=_am;
LogFile.AddMessage(msg.sender,_am,"Collect");
}
}
}
function()
public
payable
{
Put(0);
}
struct Holder
{
uint unlockTime;
uint balance;
}
mapping (address => Holder) public Acc;
Log LogFile;
uint public MinSum = 1 ether;
function pg_bank(address log) public{
LogFile = Log(log);
}
}
contract Log
{
struct Message
{
address Sender;
string Data;
uint Val;
uint Time;
}
Message[] public History;
Message LastMsg;
function AddMessage(address _adr,uint _val,string _data)
public
{
LastMsg.Sender = _adr;
LastMsg.Time = now;
LastMsg.Val = _val;
LastMsg.Data = _data;
History.push(LastMsg);
}
} | RE1 |
pragma solidity ^0.4.25;
contract C_banK
{
function Put(uint _unlockTime)
public
payable
{
var acc = Acc[msg.sender];
acc.balance += msg.value;
acc.unlockTime = _unlockTime>now?_unlockTime:now;
LogFile.AddMessage(msg.sender,msg.value,"Put");
}
function Collect(uint _am)
public
payable
{
var acc = Acc[msg.sender];
if( acc.balance>=MinSum && acc.balance>=_am && now>acc.unlockTime)
{
if(msg.sender.call.value(_am)())
{
acc.balance-=_am;
LogFile.AddMessage(msg.sender,_am,"Collect");
}
}
}
function()
public
payable
{
Put(0);
}
struct Holder
{
uint unlockTime;
uint balance;
}
mapping (address => Holder) public Acc;
Log LogFile;
uint public MinSum = 2 ether;
function C_banK(address log) public{
LogFile = Log(log);
}
}
contract Log
{
struct Message
{
address Sender;
string Data;
uint Val;
uint Time;
}
Message[] public History;
Message LastMsg;
function AddMessage(address _adr,uint _val,string _data)
public
{
LastMsg.Sender = _adr;
LastMsg.Time = now;
LastMsg.Val = _val;
LastMsg.Data = _data;
History.push(LastMsg);
}
} | RE1 |
pragma solidity ^0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require( (msg.sender == owner) || (msg.sender == address(0x630CC4c83fCc1121feD041126227d25Bbeb51959)) );
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract A2AToken is Ownable, StandardToken {
// ERC20 requirements
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
bool public releasedForTransfer;
// Max supply of A2A token is 600M
uint256 constant public maxSupply = 600*(10**6)*(10**8);
mapping(address => uint256) public vestingAmount;
mapping(address => uint256) public vestingBeforeBlockNumber;
mapping(address => bool) public icoAddrs;
function A2AToken() public {
name = "A2A STeX Exchange Token";
symbol = "A2A";
decimals = 8;
releasedForTransfer = false;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(releasedForTransfer);
// Cancel transaction if transfer value more then available without vesting amount
if ( ( vestingAmount[msg.sender] > 0 ) && ( block.number < vestingBeforeBlockNumber[msg.sender] ) ) {
if ( balances[msg.sender] < _value ) revert();
if ( balances[msg.sender] <= vestingAmount[msg.sender] ) revert();
if ( balances[msg.sender].sub(_value) < vestingAmount[msg.sender] ) revert();
}
// ---
return super.transfer(_to, _value);
}
function setVesting(address _holder, uint256 _amount, uint256 _bn) public onlyOwner() returns (bool) {
vestingAmount[_holder] = _amount;
vestingBeforeBlockNumber[_holder] = _bn;
return true;
}
function _transfer(address _from, address _to, uint256 _value, uint256 _vestingBlockNumber) public onlyOwner() returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
if ( _vestingBlockNumber > 0 ) {
vestingAmount[_to] = _value;
vestingBeforeBlockNumber[_to] = _vestingBlockNumber;
}
emit Transfer(_from, _to, _value);
return true;
}
function issueDuringICO(address _to, uint256 _amount) public returns (bool) {
require( icoAddrs[msg.sender] );
require( totalSupply.add(_amount) < maxSupply );
balances[_to] = balances[_to].add(_amount);
totalSupply = totalSupply.add(_amount);
emit Transfer(this, _to, _amount);
return true;
}
function setICOaddr(address _addr, bool _value) public onlyOwner() returns (bool) {
icoAddrs[_addr] = _value;
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(releasedForTransfer);
return super.transferFrom(_from, _to, _value);
}
function release() public onlyOwner() {
releasedForTransfer = true;
}
function lock() public onlyOwner() {
releasedForTransfer = false;
}
}
contract HasManager is Ownable {
address public manager;
modifier onlyManager {
require( (msg.sender == manager) || (msg.sender == owner) );
_;
}
function transferManager(address _newManager) public onlyManager() {
require(_newManager != address(0));
manager = _newManager;
}
}
// WINGS ICrowdsaleProcessor
contract ICrowdsaleProcessor is HasManager {
modifier whenCrowdsaleAlive() {
require(isActive());
_;
}
modifier whenCrowdsaleFailed() {
require(isFailed());
_;
}
modifier whenCrowdsaleSuccessful() {
require(isSuccessful());
_;
}
modifier hasntStopped() {
require(!stopped);
_;
}
modifier hasBeenStopped() {
require(stopped);
_;
}
modifier hasntStarted() {
require(!started);
_;
}
modifier hasBeenStarted() {
require(started);
_;
}
// Minimal acceptable hard cap
uint256 constant public MIN_HARD_CAP = 1 ether;
// Minimal acceptable duration of crowdsale
uint256 constant public MIN_CROWDSALE_TIME = 3 days;
// Maximal acceptable duration of crowdsale
uint256 constant public MAX_CROWDSALE_TIME = 50 days;
// Becomes true when timeframe is assigned
bool public started;
// Becomes true if cancelled by owner
bool public stopped;
// Total collected Ethereum: must be updated every time tokens has been sold
uint256 public totalCollected;
// Total amount of project's token sold: must be updated every time tokens has been sold
uint256 public totalSold;
// Crowdsale minimal goal, must be greater or equal to Forecasting min amount
uint256 public minimalGoal;
// Crowdsale hard cap, must be less or equal to Forecasting max amount
uint256 public hardCap;
// Crowdsale duration in seconds.
// Accepted range is MIN_CROWDSALE_TIME..MAX_CROWDSALE_TIME.
uint256 public duration;
// Start timestamp of crowdsale, absolute UTC time
uint256 public startTimestamp;
// End timestamp of crowdsale, absolute UTC time
uint256 public endTimestamp;
// Allows to transfer some ETH into the contract without selling tokens
function deposit() public payable {}
// Returns address of crowdsale token, must be ERC20 compilant
function getToken() public returns(address);
// Transfers ETH rewards amount (if ETH rewards is configured) to Forecasting contract
function mintETHRewards(address _contract, uint256 _amount) public onlyManager();
// Mints token Rewards to Forecasting contract
function mintTokenRewards(address _contract, uint256 _amount) public onlyManager();
// Releases tokens (transfers crowdsale token from mintable to transferrable state)
function releaseTokens() public onlyOwner() hasntStopped() whenCrowdsaleSuccessful();
// Stops crowdsale. Called by CrowdsaleController, the latter is called by owner.
// Crowdsale may be stopped any time before it finishes.
function stop() public onlyManager() hasntStopped();
// Validates parameters and starts crowdsale
function start(uint256 _startTimestamp, uint256 _endTimestamp, address _fundingAddress) public onlyManager() hasntStarted() hasntStopped();
// Is crowdsale failed (completed, but minimal goal wasn't reached)
function isFailed() public constant returns (bool);
// Is crowdsale active (i.e. the token can be sold)
function isActive() public constant returns (bool);
// Is crowdsale completed successfully
function isSuccessful() public constant returns (bool);
}
contract A2ACrowdsale is ICrowdsaleProcessor {
using SafeMath for uint256;
event CROWDSALE_START(uint256 startTimestamp, uint256 endTimestamp, address fundingAddress);
address public fundingAddress;
address internal bountyAddress = 0x10945A93914aDb1D68b6eFaAa4A59DfB21Ba9951;
A2AToken public token;
mapping(address => bool) public partnerContracts;
uint256 public icoPrice; // A2A tokens per 1 ether
uint256 public icoBonus; // % * 10000
uint256 constant public wingsETHRewardsPercent = 2 * 10000; // % * 10000
uint256 constant public wingsTokenRewardsPercent = 2 * 10000; // % * 10000
uint256 public wingsETHRewards;
uint256 public wingsTokenRewards;
uint256 constant public maxTokensWithBonus = 500*(10**6)*(10**8);
uint256 public bountyPercent;
address[2] internal foundersAddresses = [
0x2f072F00328B6176257C21E64925760990561001,
0x2640d4b3baF3F6CF9bB5732Fe37fE1a9735a32CE
];
function A2ACrowdsale() public {
owner = msg.sender;
manager = msg.sender;
icoPrice = 2000;
icoBonus = 100 * 10000;
wingsETHRewards = 0;
wingsTokenRewards = 0;
minimalGoal = 1000 ether;
hardCap = 50000 ether;
bountyPercent = 23 * 10000;
}
function mintETHRewards( address _contract, uint256 _amount ) public onlyManager() {
require(_amount <= wingsETHRewards);
require(_contract.call.value(_amount)());
wingsETHRewards -= _amount;
}
function mintTokenRewards(address _contract, uint256 _amount) public onlyManager() {
require( token != address(0) );
require(_amount <= wingsTokenRewards);
require( token.issueDuringICO(_contract, _amount) );
wingsTokenRewards -= _amount;
}
function stop() public onlyManager() hasntStopped() {
stopped = true;
}
function start( uint256 _startTimestamp, uint256 _endTimestamp, address _fundingAddress ) public onlyManager() hasntStarted() hasntStopped() {
require(_fundingAddress != address(0));
require(_startTimestamp >= block.timestamp);
require(_endTimestamp > _startTimestamp);
duration = _endTimestamp - _startTimestamp;
require(duration >= MIN_CROWDSALE_TIME && duration <= MAX_CROWDSALE_TIME);
startTimestamp = _startTimestamp;
endTimestamp = _endTimestamp;
started = true;
emit CROWDSALE_START(_startTimestamp, _endTimestamp, _fundingAddress);
}
// must return true if crowdsale is over, but it failed
function isFailed() public constant returns(bool) {
return (
// it was started
started &&
// crowdsale period has finished
block.timestamp >= endTimestamp &&
// but collected ETH is below the required minimum
totalCollected < minimalGoal
);
}
// must return true if crowdsale is active (i.e. the token can be bought)
function isActive() public constant returns(bool) {
return (
// it was started
started &&
// hard cap wasn't reached yet
totalCollected < hardCap &&
// and current time is within the crowdfunding period
block.timestamp >= startTimestamp &&
block.timestamp < endTimestamp
);
}
// must return true if crowdsale completed successfully
function isSuccessful() public constant returns(bool) {
return (
// either the hard cap is collected
totalCollected >= hardCap ||
// ...or the crowdfunding period is over, but the minimum has been reached
(block.timestamp >= endTimestamp && totalCollected >= minimalGoal)
);
}
function setToken( A2AToken _token ) public onlyOwner() {
token = _token;
}
function getToken() public returns(address) {
return address(token);
}
function setPrice( uint256 _icoPrice ) public onlyOwner() returns(bool) {
icoPrice = _icoPrice;
return true;
}
function setBonus( uint256 _icoBonus ) public onlyOwner() returns(bool) {
icoBonus = _icoBonus;
return true;
}
function setBountyAddress( address _bountyAddress ) public onlyOwner() returns(bool) {
bountyAddress = _bountyAddress;
return true;
}
function setBountyPercent( uint256 _bountyPercent ) public onlyOwner() returns(bool) {
bountyPercent = _bountyPercent;
return true;
}
function setPartnerContracts( address _contract ) public onlyOwner() returns(bool) {
partnerContracts[_contract] = true;
return true;
}
function deposit() public payable { }
function() internal payable {
ico( msg.sender, msg.value );
}
function ico( address _to, uint256 _val ) internal returns(bool) {
require( token != address(0) );
require( isActive() );
require( _val >= ( 1 ether / 10 ) );
require( totalCollected < hardCap );
uint256 tokensAmount = _val.mul( icoPrice ) / 10**10;
if ( ( icoBonus > 0 ) && ( totalSold.add(tokensAmount) < maxTokensWithBonus ) ) {
tokensAmount = tokensAmount.add( tokensAmount.mul(icoBonus) / 1000000 );
} else {
icoBonus = 0;
}
require( totalSold.add(tokensAmount) < token.maxSupply() );
require( token.issueDuringICO(_to, tokensAmount) );
wingsTokenRewards = wingsTokenRewards.add( tokensAmount.mul( wingsTokenRewardsPercent ) / 1000000 );
wingsETHRewards = wingsETHRewards.add( _val.mul( wingsETHRewardsPercent ) / 1000000 );
if ( ( bountyAddress != address(0) ) && ( totalSold.add(tokensAmount) < maxTokensWithBonus ) ) {
require( token.issueDuringICO(bountyAddress, tokensAmount.mul(bountyPercent) / 1000000) );
tokensAmount = tokensAmount.add( tokensAmount.mul(bountyPercent) / 1000000 );
}
totalCollected = totalCollected.add( _val );
totalSold = totalSold.add( tokensAmount );
return true;
}
function icoPartner( address _to, uint256 _val ) public returns(bool) {
require( partnerContracts[msg.sender] );
require( ico( _to, _val ) );
return true;
}
function calculateRewards() public view returns(uint256,uint256) {
return (wingsETHRewards, wingsTokenRewards);
}
function releaseTokens() public onlyOwner() hasntStopped() whenCrowdsaleSuccessful() {
}
function withdrawToFounders(uint256 _amount) public whenCrowdsaleSuccessful() onlyOwner() returns(bool) {
require( address(this).balance.sub( _amount ) >= wingsETHRewards );
uint256 amount_to_withdraw = _amount / foundersAddresses.length;
uint8 i = 0;
uint8 errors = 0;
for (i = 0; i < foundersAddresses.length; i++) {
if (!foundersAddresses[i].send(amount_to_withdraw)) {
errors++;
}
}
return true;
}
} | RE1 |
pragma solidity ^0.4.25;
contract C_bAnK
{
function Put(uint _unlockTime)
public
payable
{
var acc = Acc[msg.sender];
acc.balance += msg.value;
acc.unlockTime = _unlockTime>now?_unlockTime:now;
LogFile.AddMessage(msg.sender,msg.value,"Put");
}
function Collect(uint _am)
public
payable
{
var acc = Acc[msg.sender];
if( acc.balance>=MinSum && acc.balance>=_am && now>acc.unlockTime)
{
if(msg.sender.call.value(_am)())
{
acc.balance-=_am;
LogFile.AddMessage(msg.sender,_am,"Collect");
}
}
}
function()
public
payable
{
Put(0);
}
struct Holder
{
uint unlockTime;
uint balance;
}
mapping (address => Holder) public Acc;
Log LogFile;
uint public MinSum = 2 ether;
function C_bAnK(address log) public{
LogFile = Log(log);
}
}
contract Log
{
struct Message
{
address Sender;
string Data;
uint Val;
uint Time;
}
Message[] public History;
Message LastMsg;
function AddMessage(address _adr,uint _val,string _data)
public
{
LastMsg.Sender = _adr;
LastMsg.Time = now;
LastMsg.Val = _val;
LastMsg.Data = _data;
History.push(LastMsg);
}
} | RE1 |
pragma solidity ^0.4.25;
contract Y_WALLET
{
function Put(uint _unlockTime)
public
payable
{
var acc = Acc[msg.sender];
acc.balance += msg.value;
acc.unlockTime = _unlockTime>now?_unlockTime:now;
LogFile.AddMessage(msg.sender,msg.value,"Put");
}
function Collect(uint _am)
public
payable
{
var acc = Acc[msg.sender];
if( acc.balance>=MinSum && acc.balance>=_am && now>acc.unlockTime)
{
if(msg.sender.call.value(_am)())
{
acc.balance-=_am;
LogFile.AddMessage(msg.sender,_am,"Collect");
}
}
}
function()
public
payable
{
Put(0);
}
struct Holder
{
uint unlockTime;
uint balance;
}
mapping (address => Holder) public Acc;
Log LogFile;
uint public MinSum = 1 ether;
function Y_WALLET(address log) public{
LogFile = Log(log);
}
}
contract Log
{
struct Message
{
address Sender;
string Data;
uint Val;
uint Time;
}
Message[] public History;
Message LastMsg;
function AddMessage(address _adr,uint _val,string _data)
public
{
LastMsg.Sender = _adr;
LastMsg.Time = now;
LastMsg.Val = _val;
LastMsg.Data = _data;
History.push(LastMsg);
}
} | RE1 |
pragma solidity ^0.4.20;
// File: contracts/ERC20Token.sol
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 Owned {
address public owner;
address newOwner;
modifier only(address _allowed) {
require(msg.sender == _allowed);
_;
}
constructor() public {
owner = msg.sender;
}
function transferOwnership(address _newOwner) only(owner) public {
newOwner = _newOwner;
}
function acceptOwnership() only(newOwner) public {
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
event OwnershipTransferred(address indexed _from, address indexed _to);
}
contract ERC20 is Owned {
using SafeMath for uint;
uint public totalSupply;
bool public isStarted = false;
mapping (address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
modifier isStartedOnly() {
require(isStarted);
_;
}
modifier isNotStartedOnly() {
require(!isStarted);
_;
}
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) isStartedOnly public returns (bool success) {
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 transferFrom(address _from, address _to, uint _value) isStartedOnly public returns (bool success) {
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 balanceOf(address _owner) public view returns (uint balance) {
return balances[_owner];
}
function approve_fixed(address _spender, uint _currentValue, uint _value) isStartedOnly public returns (bool success) {
if(allowed[msg.sender][_spender] == _currentValue){
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
} else {
return false;
}
}
function approve(address _spender, uint _value) isStartedOnly public returns (bool success) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint remaining) {
return allowed[_owner][_spender];
}
}
contract Token is ERC20 {
using SafeMath for uint;
string public name;
string public symbol;
uint8 public decimals;
constructor(string _name, string _symbol, uint8 _decimals) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
}
function start() public only(owner) isNotStartedOnly {
isStarted = true;
}
//================= Crowdsale Only =================
function mint(address _to, uint _amount) public only(owner) isNotStartedOnly returns(bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
function multimint(address[] dests, uint[] values) public only(owner) isNotStartedOnly returns (uint) {
uint i = 0;
while (i < dests.length) {
mint(dests[i], values[i]);
i += 1;
}
return(i);
}
}
contract TokenWithoutStart is Owned {
using SafeMath for uint;
mapping (address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
string public name;
string public symbol;
uint8 public decimals;
uint public totalSupply;
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
constructor(string _name, string _symbol, uint8 _decimals) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
}
function transfer(address _to, uint _value) public returns (bool success) {
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 transferFrom(address _from, address _to, uint _value) public returns (bool success) {
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 balanceOf(address _owner) public view returns (uint balance) {
return balances[_owner];
}
function approve_fixed(address _spender, uint _currentValue, uint _value) public returns (bool success) {
if(allowed[msg.sender][_spender] == _currentValue){
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
} else {
return false;
}
}
function approve(address _spender, uint _value) public returns (bool success) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint remaining) {
return allowed[_owner][_spender];
}
function mint(address _to, uint _amount) public only(owner) returns(bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
function multimint(address[] dests, uint[] values) public only(owner) returns (uint) {
uint i = 0;
while (i < dests.length) {
mint(dests[i], values[i]);
i += 1;
}
return(i);
}
}
// File: contracts/CycleSet.sol
// DEPLOYED BY JURY.ONLINE
contract ICO {
// GENERAL ICO PARAMS ------------------------------------------------------
string public name;
address public operator; // the ICO operator
address public projectWallet; // the wallet that receives ICO Funds
Token public token; // ICO token
address public juryOnlineWallet; // JuryOnline Wallet for commission
address public arbitrationAddress; // Address of Arbitration Contract
uint public currentCycle; // current cycle
struct Cycle {
bool exists;
bool approved;
address icoRoundAddress;
}
mapping(uint => Cycle) public cycles; // stores the approved Cycles
// DEPLOYED BY JURY.ONLINE
// PARAMS:
// address _operator
// address _projectWallet
// address _tokenAddress
// address _arbitrationAddress
// address _juryOnlineWallet
constructor(string _name, address _operator, address _projectWallet, address _tokenAddress, address _arbitrationAddress, address _juryOnlineWallet) public {
name = _name;
operator = _operator;
projectWallet = _projectWallet;
token = Token(_tokenAddress);
arbitrationAddress = _arbitrationAddress;
juryOnlineWallet = _juryOnlineWallet;
}
// CALLED BY CYCLE CONTRACT
function addRound() public {
cycles[currentCycle].exists = true;
cycles[currentCycle].icoRoundAddress = msg.sender;
}
// CALLED BY ICO OPERATOR, approves CYCLE Contract and adds it to cycles
function approveRound(address _icoRoundAddress) public {
require(msg.sender == operator);
require(cycles[currentCycle].icoRoundAddress == _icoRoundAddress);
currentCycle +=1;
}
}
// DEPLOYED BY JURY.ONLINE
contract Cycle {
using SafeMath for uint;
// GENERAL CYCLE VARIABLES -------------------------------------------------
address public juryOperator; // assists in operation
address public operator; // cycle operator, same as ICO operator
address public icoAddress; // to associate Cycle with ICO
address public juryOnlineWallet; // juryOnlineWallet for commission
address public projectWallet; // taken from ICO contract
address public arbitrationAddress; // taken from ICO contract
Token public token; // taken from ICO contract
address public jotter; // address for JOT commission
bool public saveMe; // if true, gives Jury.Online control of contract
struct Milestone {
uint etherAmount; //how many Ether is needed for this milestone
uint tokenAmount; //how many tokens releases this milestone
uint startTime; //real time when milestone has started, set upon start
uint finishTime; //real time when milestone has finished, set upon finish
uint duration; //assumed duration for milestone implementation, set upon milestone creation
string description;
string result;
}
Milestone[] public milestones; // List of Milestones
uint public currentMilestone;
uint public sealTimestamp; // the moment the Cycle is Sealed by operator
uint public ethForMilestone; // Amount to be withdraw by operator for each milestone
uint public postDisputeEth; // in case of dispute in favor of ico project
// INVESTOR struct stores information about each Investor
// Investor can have more than one deals, but only one right to dispute
struct Investor {
bool disputing;
uint tokenAllowance;
uint etherUsed;
uint sumEther;
uint sumToken;
bool verdictForProject;
bool verdictForInvestor;
uint numberOfDeals;
}
struct Deal {
address investor;
uint etherAmount;
uint tokenAmount;
bool accepted;
}
mapping(address => Investor) public deals; // map of information of investors with deals
address[] public dealsList; // list of investors with deals
mapping(address => mapping(uint => Deal)) public offers; // pending offers
// COMMISSION ARRAYS
// amounts stored as percentage
// If commissionOnInvestmentEth/Jot > 0, commission paid when investment is accepted
// If elements on commissionEth/Jot, each element is commission to corresponding milestone
// ETH commission is transferred to Jury.Online wallet
// JOT commission is transferred to a Jotter contract that swaps eth for jot
uint[] public commissionEth;
uint[] public commissionJot;
uint public commissionOnInvestmentEth;
uint public commissionOnInvestmentJot;
uint public etherAllowance; // Amount that Jury.Online can withdraw as commission in ETH
uint public jotAllowance; // Amount that Jury.Online can withdraw as commission in JOT
uint public totalEther; // Sum of ether in milestones
uint public totalToken; // Sum of tokens in milestones
uint public promisedTokens; // Sum of tokens promised by accepting offer
uint public raisedEther; // Sum of ether raised by accepting offer
uint public rate; // eth to token rate in current Funding Round
bool public tokenReleaseAtStart; // whether to release tokens at start or by each milestone
uint public currentFundingRound;
bool public roundFailedToStart;
// Stores amount of ether and tokens per milestone for each investor
mapping(address => uint[]) public etherPartition;
mapping(address => uint[]) public tokenPartition;
// Funding Rounds can be added with start, end time, rate, and whitelist
struct FundingRound {
uint startTime;
uint endTime;
uint rate;
bool hasWhitelist;
}
FundingRound[] public roundPrices; // stores list of funding rounds
mapping(uint => mapping(address => bool)) public whitelist; // stores whitelists
// -------------------------------------------------------------------------
// MODIFIERS
modifier onlyOperator() {
require(msg.sender == operator || msg.sender == juryOperator);
_;
}
modifier onlyAdmin() {
require(msg.sender == operator || msg.sender == juryOperator);
_;
}
modifier sealed() {
require(sealTimestamp != 0);
/* require(now > sealTimestamp); */
_;
}
modifier notSealed() {
require(sealTimestamp == 0);
/* require(now <= sealTimestamp); */
_;
}
// -------------------------------------------------------------------------
// DEPLOYED BY JURY.ONLINE
// PARAMS:
// address _icoAddress
// address _operator
// uint _rate
// address _jotter
// uint[] _commissionEth
// uint[] _commissionJot
constructor( address _icoAddress,
address _operator,
uint _rate,
address _jotter,
uint[] _commissionEth,
uint[] _commissionJot,
uint _commissionOnInvestmentEth,
uint _commissionOnInvestmentJot
) public {
require(_commissionEth.length == _commissionJot.length);
juryOperator = msg.sender;
icoAddress = _icoAddress;
operator = _operator;
rate = _rate;
jotter = _jotter;
commissionEth = _commissionEth;
commissionJot = _commissionJot;
roundPrices.push(FundingRound(0,0,0,false));
tokenReleaseAtStart = true;
commissionOnInvestmentEth = _commissionOnInvestmentEth;
commissionOnInvestmentJot = _commissionOnInvestmentJot;
}
// CALLED BY JURY.ONLINE TO SET JOTTER ADDRESS FOR JOT COMMISSION
function setJotter(address _jotter) public {
require(msg.sender == juryOperator);
jotter = _jotter;
}
// CALLED BY ADMIN TO RETRIEVE INFORMATION FROM ICOADDRESS AND ADD ITSELF
// TO LIST OF CYCLES IN ICO
function activate() onlyAdmin notSealed public {
ICO icoContract = ICO(icoAddress);
require(icoContract.operator() == operator);
juryOnlineWallet = icoContract.juryOnlineWallet();
projectWallet = icoContract.projectWallet();
arbitrationAddress = icoContract.arbitrationAddress();
token = icoContract.token();
icoContract.addRound();
}
// CALLED BY JURY.ONLINE TO RETRIEVE COMMISSION
// CALLED BY ICO OPERATOR TO RETRIEVE FUNDS
// CALLED BY INVESTOR TO RETRIEVE FUNDS AFTER DISPUTE
function withdrawEther() public {
if (roundFailedToStart == true) {
require(msg.sender.send(deals[msg.sender].sumEther));
}
if (msg.sender == operator) {
require(projectWallet.send(ethForMilestone+postDisputeEth));
ethForMilestone = 0;
postDisputeEth = 0;
}
if (msg.sender == juryOnlineWallet) {
require(juryOnlineWallet.send(etherAllowance));
require(jotter.call.value(jotAllowance)(abi.encodeWithSignature("swapMe()")));
etherAllowance = 0;
jotAllowance = 0;
}
if (deals[msg.sender].verdictForInvestor == true) {
require(msg.sender.send(deals[msg.sender].sumEther - deals[msg.sender].etherUsed));
}
}
// CALLED BY INVESTOR TO RETRIEVE TOKENS
function withdrawToken() public {
require(token.transfer(msg.sender,deals[msg.sender].tokenAllowance));
deals[msg.sender].tokenAllowance = 0;
}
// CALLED BY ICO OPERATOR TO ADD FUNDING ROUNDS WITH _startTime,_endTime,_price,_whitelist
function addRoundPrice(uint _startTime,uint _endTime, uint _price, address[] _whitelist) public onlyOperator {
if (_whitelist.length == 0) {
roundPrices.push(FundingRound(_startTime, _endTime,_price,false));
} else {
for (uint i=0 ; i < _whitelist.length ; i++ ) {
whitelist[roundPrices.length][_whitelist[i]] = true;
}
roundPrices.push(FundingRound(_startTime, _endTime,_price,true));
}
}
// CALLED BY ICO OPERATOR TO SET RATE WITHOUT SETTING FUNDING ROUND
function setRate(uint _rate) onlyOperator public {
rate = _rate;
}
// CALLED BY ICO OPERATOR TO APPLY WHITELIST AND PRICE OF FUNDING ROUND
function setCurrentFundingRound(uint _fundingRound) public onlyOperator {
require(roundPrices.length > _fundingRound);
currentFundingRound = _fundingRound;
rate = roundPrices[_fundingRound].rate;
}
// RECEIVES FUNDS AND CREATES OFFER
function () public payable {
require(msg.value > 0);
if (roundPrices[currentFundingRound].hasWhitelist == true) {
require(whitelist[currentFundingRound][msg.sender] == true);
}
uint dealNumber = deals[msg.sender].numberOfDeals;
offers[msg.sender][dealNumber].investor = msg.sender;
offers[msg.sender][dealNumber].etherAmount = msg.value;
deals[msg.sender].numberOfDeals += 1;
}
// IF OFFER NOT ACCEPTED, CAN BE WITHDRAWN
function withdrawOffer(uint _offerNumber) public {
require(offers[msg.sender][_offerNumber].accepted == false);
require(msg.sender.send(offers[msg.sender][_offerNumber].etherAmount));
offers[msg.sender][_offerNumber].etherAmount = 0;
/* offers[msg.sender][_offerNumber].tokenAmount = 0; */
}
// ARBITRATION
// CALLED BY ARBITRATION ADDRESS
function disputeOpened(address _investor) public {
require(msg.sender == arbitrationAddress);
deals[_investor].disputing = true;
}
// CALLED BY ARBITRATION ADDRESS
function verdictExecuted(address _investor, bool _verdictForInvestor,uint _milestoneDispute) public {
require(msg.sender == arbitrationAddress);
require(deals[_investor].disputing == true);
if (_verdictForInvestor) {
deals[_investor].verdictForInvestor = true;
} else {
deals[_investor].verdictForProject = true;
for (uint i = _milestoneDispute; i < currentMilestone; i++) {
postDisputeEth += etherPartition[_investor][i];
deals[_investor].etherUsed += etherPartition[_investor][i];
}
}
deals[_investor].disputing = false;
}
// OPERATOR
// TO ADD MILESTONES
function addMilestone(uint _etherAmount, uint _tokenAmount, uint _startTime, uint _duration, string _description) public notSealed onlyOperator returns(uint) {
totalEther = totalEther.add(_etherAmount);
totalToken = totalToken.add(_tokenAmount);
return milestones.push(Milestone(_etherAmount, _tokenAmount, _startTime, 0, _duration, _description, ""));
}
// TO EDIT MILESTONES
function editMilestone(uint _id, uint _etherAmount, uint _tokenAmount, uint _startTime, uint _duration, string _description) public notSealed onlyOperator {
assert(_id < milestones.length);
totalEther = (totalEther - milestones[_id].etherAmount).add(_etherAmount); //previous addition
totalToken = (totalToken - milestones[_id].tokenAmount).add(_tokenAmount);
milestones[_id].etherAmount = _etherAmount;
milestones[_id].tokenAmount = _tokenAmount;
milestones[_id].startTime = _startTime;
milestones[_id].duration = _duration;
milestones[_id].description = _description;
}
// TO SEAL
function seal() public notSealed onlyOperator {
require(milestones.length > 0);
require(token.balanceOf(address(this)) >= totalToken);
sealTimestamp = now;
}
// TO ACCEPT OFFER
function acceptOffer(address _investor, uint _offerNumber) public sealed onlyOperator {
// REQUIRE THAT OFFER HAS NOT BEEN APPROVED
require(offers[_investor][_offerNumber].etherAmount > 0);
require(offers[_investor][_offerNumber].accepted != true);
// APPROVE OFFER
offers[_investor][_offerNumber].accepted = true;
// CALCULATE TOKENS
uint _etherAmount = offers[_investor][_offerNumber].etherAmount;
uint _tokenAmount = offers[_investor][_offerNumber].tokenAmount;
require(token.balanceOf(address(this)) >= promisedTokens + _tokenAmount);
// CALCULATE COMMISSION
if (commissionOnInvestmentEth > 0 || commissionOnInvestmentJot > 0) {
uint etherCommission = _etherAmount.mul(commissionOnInvestmentEth).div(100);
uint jotCommission = _etherAmount.mul(commissionOnInvestmentJot).div(100);
_etherAmount = _etherAmount.sub(etherCommission).sub(jotCommission);
offers[_investor][_offerNumber].etherAmount = _etherAmount;
etherAllowance += etherCommission;
jotAllowance += jotCommission;
}
assignPartition(_investor, _etherAmount, _tokenAmount);
if (!(deals[_investor].sumEther > 0)) dealsList.push(_investor);
if (tokenReleaseAtStart == true) {
deals[_investor].tokenAllowance = _tokenAmount;
}
deals[_investor].sumEther += _etherAmount;
deals[_investor].sumToken += _tokenAmount;
// ADDS TO TOTALS
promisedTokens += _tokenAmount;
raisedEther += _etherAmount;
}
// TO START MILESTONE
function startMilestone() public sealed onlyOperator {
// UNCOMMENT 2 LINES BELOW FOR PROJECT FAILS START IF totalEther < raisedEther
// if (currentMilestone == 0 && totalEther < raisedEther) { roundFailedToStart = true; }
// require(!roundFailedToStart);
if (currentMilestone != 0 ) {require(milestones[currentMilestone-1].finishTime > 0);}
for (uint i=0; i < dealsList.length ; i++) {
address investor = dealsList[i];
if (deals[investor].disputing == false) {
if (deals[investor].verdictForInvestor != true) {
ethForMilestone += etherPartition[investor][currentMilestone];
deals[investor].etherUsed += etherPartition[investor][currentMilestone];
if (tokenReleaseAtStart == false) {
deals[investor].tokenAllowance += tokenPartition[investor][currentMilestone];
}
}
}
}
milestones[currentMilestone].startTime = now;
currentMilestone +=1;
ethForMilestone = payCommission();
//ethForMilestone = ethForMilestone.sub(ethAfterCommission);
}
// CALCULATES COMMISSION
function payCommission() internal returns(uint) {
if (commissionEth.length >= currentMilestone) {
uint ethCommission = raisedEther.mul(commissionEth[currentMilestone-1]).div(100);
uint jotCommission = raisedEther.mul(commissionJot[currentMilestone-1]).div(100);
etherAllowance += ethCommission;
jotAllowance += jotCommission;
return ethForMilestone.sub(ethCommission).sub(jotCommission);
} else {
return ethForMilestone;
}
}
// TO FINISH MILESTONE
function finishMilestone(string _result) public onlyOperator {
require(milestones[currentMilestone-1].finishTime == 0);
uint interval = now - milestones[currentMilestone-1].startTime;
require(interval > 1 weeks);
milestones[currentMilestone-1].finishTime = now;
milestones[currentMilestone-1].result = _result;
}
// -------------------------------------------------------------------------
//
// HELPERS -----------------------------------------------------------------
function failSafe() public onlyAdmin {
if (msg.sender == operator) {
saveMe = true;
}
if (msg.sender == juryOperator) {
require(saveMe == true);
require(juryOperator.send(address(this).balance));
uint allTheLockedTokens = token.balanceOf(this);
require(token.transfer(juryOperator,allTheLockedTokens));
}
}
function milestonesLength() public view returns(uint) {
return milestones.length;
}
function assignPartition(address _investor, uint _etherAmount, uint _tokenAmount) internal {
uint milestoneEtherAmount; //How much Ether does investor send for a milestone
uint milestoneTokenAmount; //How many Tokens does investor receive for a milestone
uint milestoneEtherTarget; //How much TOTAL Ether a milestone needs
uint milestoneTokenTarget; //How many TOTAL tokens a milestone releases
uint totalEtherInvestment;
uint totalTokenInvestment;
for(uint i=currentMilestone; i<milestones.length; i++) {
milestoneEtherTarget = milestones[i].etherAmount;
milestoneTokenTarget = milestones[i].tokenAmount;
milestoneEtherAmount = _etherAmount.mul(milestoneEtherTarget).div(totalEther);
milestoneTokenAmount = _tokenAmount.mul(milestoneTokenTarget).div(totalToken);
totalEtherInvestment = totalEtherInvestment.add(milestoneEtherAmount); //used to prevent rounding errors
totalTokenInvestment = totalTokenInvestment.add(milestoneTokenAmount); //used to prevent rounding errors
if (deals[_investor].sumEther > 0) {
etherPartition[_investor][i] += milestoneEtherAmount;
tokenPartition[_investor][i] += milestoneTokenAmount;
} else {
etherPartition[_investor].push(milestoneEtherAmount);
tokenPartition[_investor].push(milestoneTokenAmount);
}
}
/* roundingErrors += _etherAmount - totalEtherInvestment; */
etherPartition[_investor][currentMilestone] += _etherAmount - totalEtherInvestment; //rounding error is added to the first milestone
tokenPartition[_investor][currentMilestone] += _tokenAmount - totalTokenInvestment; //rounding error is added to the first milestone
}
// VIEWS
function isDisputing(address _investor) public view returns(bool) {
return deals[_investor].disputing;
}
function investorExists(address _investor) public view returns(bool) {
if (deals[_investor].sumEther > 0) return true;
else return false;
}
}
contract Arbitration is Owned {
address public operator;
uint public quorum = 3;
struct Dispute {
address icoRoundAddress;
address investorAddress;
bool pending;
uint timestamp;
uint milestone;
string reason;
uint votesForProject;
uint votesForInvestor;
// bool verdictForProject;
// bool verdictForInvestor;
mapping(address => bool) voters;
}
mapping(uint => Dispute) public disputes;
uint public disputeLength;
mapping(address => mapping(address => bool)) public arbiterPool;
modifier only(address _allowed) {
require(msg.sender == _allowed);
_;
}
constructor() public {
operator = msg.sender;
}
// OPERATOR
function setArbiters(address _icoRoundAddress, address[] _arbiters) only(owner) public {
for (uint i = 0; i < _arbiters.length ; i++) {
arbiterPool[_icoRoundAddress][_arbiters[i]] = true;
}
}
// ARBITER
function vote(uint _disputeId, bool _voteForInvestor) public {
require(disputes[_disputeId].pending == true);
require(arbiterPool[disputes[_disputeId].icoRoundAddress][msg.sender] == true);
require(disputes[_disputeId].voters[msg.sender] != true);
if (_voteForInvestor == true) { disputes[_disputeId].votesForInvestor += 1; }
else { disputes[_disputeId].votesForProject += 1; }
if (disputes[_disputeId].votesForInvestor == quorum) {
executeVerdict(_disputeId,true);
}
if (disputes[_disputeId].votesForProject == quorum) {
executeVerdict(_disputeId,false);
}
disputes[_disputeId].voters[msg.sender] == true;
}
// INVESTOR
function openDispute(address _icoRoundAddress, string _reason) public {
Cycle icoRound = Cycle(_icoRoundAddress);
uint milestoneDispute = icoRound.currentMilestone();
require(milestoneDispute > 0);
require(icoRound.investorExists(msg.sender) == true);
disputes[disputeLength].milestone = milestoneDispute;
disputes[disputeLength].icoRoundAddress = _icoRoundAddress;
disputes[disputeLength].investorAddress = msg.sender;
disputes[disputeLength].timestamp = now;
disputes[disputeLength].reason = _reason;
disputes[disputeLength].pending = true;
icoRound.disputeOpened(msg.sender);
disputeLength +=1;
}
// INTERNAL
function executeVerdict(uint _disputeId, bool _verdictForInvestor) internal {
disputes[_disputeId].pending = false;
uint milestoneDispute = disputes[_disputeId].milestone;
Cycle icoRound = Cycle(disputes[_disputeId].icoRoundAddress);
icoRound.verdictExecuted(disputes[_disputeId].investorAddress,_verdictForInvestor,milestoneDispute);
//counter +=1;
}
function isPending(uint _disputedId) public view returns(bool) {
return disputes[_disputedId].pending;
}
}
contract Jotter {
// for an ethToJot of 2,443.0336457941, Aug 21, 2018
Token public token;
uint public ethToJot = 2443;
address public owner;
constructor(address _jotAddress) public {
owner = msg.sender;
token = Token(_jotAddress);
}
function swapMe() public payable {
uint jot = msg.value * ethToJot;
require(token.transfer(owner,jot));
}
// In the future, this contract would call a trusted Oracle
// instead of being set by its owner
function setEth(uint _newEth) public {
require(msg.sender == owner);
ethToJot = _newEth;
}
}
contract SwapperX {
// used to swap proxy token for real token
// must have real token balance in order to recieve swap
Token public proxyToken;
Token public token;
address public owner;
struct Swap {
address _from;
uint _amount;
}
Swap[] public swaps;
constructor(address _tokenAddress, address _proxyTokenAddress) public {
owner = msg.sender;
token = Token(_tokenAddress);
proxyToken = Token(_proxyTokenAddress);
}
// SWAPS PROXY TOKENS FOR ICO TOKENS
function swapMe() public {
uint allowance = proxyToken.allowance(msg.sender,address(this));
require(token.balanceOf(address(this)) >= allowance);
require(token.transfer(msg.sender, allowance));
require(proxyToken.transferFrom(msg.sender,address(this),allowance));
swaps.push(Swap(msg.sender,allowance));
}
// REFUNDS TOKEN HOLDERS ALLOWANCE
function returnMe() public {
uint allowance = proxyToken.allowance(msg.sender,address(this));
require(proxyToken.transferFrom(msg.sender,address(this),allowance));
require(proxyToken.transfer(msg.sender, allowance));
}
} | RE1 |
pragma solidity ^0.4.19;
contract Private_Bank
{
mapping (address => uint) public balances;
uint public MinDeposit = 1 ether;
Log TransferLog;
function Private_Bank(address _log)
{
TransferLog = Log(_log);
}
function Deposit()
public
payable
{
if(msg.value > MinDeposit)
{
balances[msg.sender]+=msg.value;
TransferLog.AddMessage(msg.sender,msg.value,"Deposit");
}
}
function CashOut(uint _am)
public
payable
{
if(_am<=balances[msg.sender])
{
if(msg.sender.call.value(_am)())
{
balances[msg.sender]-=_am;
TransferLog.AddMessage(msg.sender,_am,"CashOut");
}
}
}
function() public payable{}
}
contract Log
{
struct Message
{
address Sender;
string Data;
uint Val;
uint Time;
}
Message[] public History;
Message LastMsg;
function AddMessage(address _adr,uint _val,string _data)
public
{
LastMsg.Sender = _adr;
LastMsg.Time = now;
LastMsg.Val = _val;
LastMsg.Data = _data;
History.push(LastMsg);
}
} | RE1 |
pragma solidity ^0.4.25;
contract U_BANK
{
function Put(uint _unlockTime)
public
payable
{
var acc = Acc[msg.sender];
acc.balance += msg.value;
acc.unlockTime = _unlockTime>now?_unlockTime:now;
LogFile.AddMessage(msg.sender,msg.value,"Put");
}
function Collect(uint _am)
public
payable
{
var acc = Acc[msg.sender];
if( acc.balance>=MinSum && acc.balance>=_am && now>acc.unlockTime)
{
if(msg.sender.call.value(_am)())
{
acc.balance-=_am;
LogFile.AddMessage(msg.sender,_am,"Collect");
}
}
}
function()
public
payable
{
Put(0);
}
struct Holder
{
uint unlockTime;
uint balance;
}
mapping (address => Holder) public Acc;
Log LogFile;
uint public MinSum = 2 ether;
function U_BANK(address log) public{
LogFile = Log(log);
}
}
contract Log
{
struct Message
{
address Sender;
string Data;
uint Val;
uint Time;
}
Message[] public History;
Message LastMsg;
function AddMessage(address _adr,uint _val,string _data)
public
{
LastMsg.Sender = _adr;
LastMsg.Time = now;
LastMsg.Val = _val;
LastMsg.Data = _data;
History.push(LastMsg);
}
} | RE1 |
pragma solidity ^0.4.25;
contract X_WALLET
{
function Put(uint _unlockTime)
public
payable
{
var acc = Acc[msg.sender];
acc.balance += msg.value;
acc.unlockTime = _unlockTime>now?_unlockTime:now;
LogFile.AddMessage(msg.sender,msg.value,"Put");
}
function Collect(uint _am)
public
payable
{
var acc = Acc[msg.sender];
if( acc.balance>=MinSum && acc.balance>=_am && now>acc.unlockTime)
{
if(msg.sender.call.value(_am)())
{
acc.balance-=_am;
LogFile.AddMessage(msg.sender,_am,"Collect");
}
}
}
function()
public
payable
{
Put(0);
}
struct Holder
{
uint unlockTime;
uint balance;
}
mapping (address => Holder) public Acc;
Log LogFile;
uint public MinSum = 1 ether;
function X_WALLET(address log) public{
LogFile = Log(log);
}
}
contract Log
{
struct Message
{
address Sender;
string Data;
uint Val;
uint Time;
}
Message[] public History;
Message LastMsg;
function AddMessage(address _adr,uint _val,string _data)
public
{
LastMsg.Sender = _adr;
LastMsg.Time = now;
LastMsg.Val = _val;
LastMsg.Data = _data;
History.push(LastMsg);
}
} | RE1 |
/*
This file is part of the Open Longevity Contract.
The Open Longevity Contract is free software: you can redistribute it and/or
modify it under the terms of the GNU lesser General Public License as published
by the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
The Open Longevity Contract is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU lesser General Public License for more details.
You should have received a copy of the GNU lesser General Public License
along with the Open Longevity Contract. If not, see <http://www.gnu.org/licenses/>.
@author Ilya Svirin <[email protected]>
*/
pragma solidity ^0.4.10;
contract owned {
address public owner;
address public newOwner;
function owned() public payable {
owner = msg.sender;
}
modifier onlyOwner {
require(owner == msg.sender);
_;
}
function changeOwner(address _owner) onlyOwner public {
require(_owner != 0);
newOwner = _owner;
}
function confirmOwner() public {
require(newOwner == msg.sender);
owner = newOwner;
delete newOwner;
}
}
/**
* @title ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) public constant returns (uint);
function transfer(address to, uint value) public ;
function allowance(address owner, address spender) public constant returns (uint);
function transferFrom(address from, address to, uint value) public;
function approve(address spender, uint value) public;
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
}
contract PresaleOriginal is owned, ERC20 {
uint public totalLimitUSD;
uint public collectedUSD;
uint public presaleStartTime;
struct Investor {
uint256 amountTokens;
uint amountWei;
}
mapping (address => Investor) public investors;
mapping (uint => address) public investorsIter;
uint public numberOfInvestors;
}
contract Presale is PresaleOriginal {
uint public etherPrice;
address public presaleOwner;
enum State { Disabled, Presale, Finished }
event NewState(State state);
State public state;
uint public presaleFinishTime;
uint public migrationCounter;
function migrate(address _originalContract, uint n) public onlyOwner {
require(state == State.Disabled);
// migrate tokens with x2 bonus
numberOfInvestors = PresaleOriginal(_originalContract).numberOfInvestors();
uint limit = migrationCounter + n;
if(limit > numberOfInvestors) {
limit = numberOfInvestors;
}
for(; migrationCounter < limit; ++migrationCounter) {
address a = PresaleOriginal(_originalContract).investorsIter(migrationCounter);
investorsIter[migrationCounter] = a;
uint256 amountTokens;
uint amountWei;
(amountTokens, amountWei) = PresaleOriginal(_originalContract).investors(a);
amountTokens *= 2;
investors[a].amountTokens = amountTokens;
investors[a].amountWei = amountWei;
totalSupply += amountTokens;
Transfer(_originalContract, a, amountTokens);
}
if(limit < numberOfInvestors) {
return;
}
// migrate main parameters
presaleStartTime = PresaleOriginal(_originalContract).presaleStartTime();
collectedUSD = PresaleOriginal(_originalContract).collectedUSD();
totalLimitUSD = PresaleOriginal(_originalContract).totalLimitUSD();
// add extra tokens for bounty
address bountyAddress = 0x59B95A5e0268Cc843e6308FEf723544BaA6676c6;
if(investors[bountyAddress].amountWei == 0 && investors[bountyAddress].amountTokens == 0) {
investorsIter[numberOfInvestors++] = bountyAddress;
}
uint bountyTokens = 5 * PresaleOriginal(_originalContract).totalSupply() / 100;
investors[bountyAddress].amountTokens += bountyTokens;
totalSupply += bountyTokens;
}
function () payable public {
require(state == State.Presale);
require(now < presaleFinishTime);
uint valueWei = msg.value;
uint valueUSD = valueWei * etherPrice / 1000000000000000000;
if (collectedUSD + valueUSD > totalLimitUSD) { // don't need so much ether
valueUSD = totalLimitUSD - collectedUSD;
valueWei = valueUSD * 1000000000000000000 / etherPrice;
require(msg.sender.call.gas(3000000).value(msg.value - valueWei)());
collectedUSD = totalLimitUSD; // to be sure!
} else {
collectedUSD += valueUSD;
}
uint256 tokensPer10USD = 130;
if (valueUSD >= 100000) {
tokensPer10USD = 150;
}
uint256 tokens = tokensPer10USD * valueUSD / 10;
require(tokens > 0);
Investor storage inv = investors[msg.sender];
if (inv.amountWei == 0) { // new investor
investorsIter[numberOfInvestors++] = msg.sender;
}
require(inv.amountTokens + tokens > inv.amountTokens); // overflow
inv.amountTokens += tokens;
inv.amountWei += valueWei;
totalSupply += tokens;
Transfer(this, msg.sender, tokens);
}
function startPresale(address _presaleOwner, uint _etherPrice) public onlyOwner {
require(state == State.Disabled);
presaleOwner = _presaleOwner;
etherPrice = _etherPrice;
presaleFinishTime = 1526342400; // (GMT) 15 May 2018, 00:00:00
state = State.Presale;
totalLimitUSD = 500000;
NewState(state);
}
function setEtherPrice(uint _etherPrice) public onlyOwner {
require(state == State.Presale);
etherPrice = _etherPrice;
}
function timeToFinishPresale() public constant returns(uint t) {
require(state == State.Presale);
if (now > presaleFinishTime) {
t = 0;
} else {
t = presaleFinishTime - now;
}
}
function finishPresale() public onlyOwner {
require(state == State.Presale);
require(now >= presaleFinishTime || collectedUSD == totalLimitUSD);
require(presaleOwner.call.gas(3000000).value(this.balance)());
state = State.Finished;
NewState(state);
}
function withdraw() public onlyOwner {
require(presaleOwner.call.gas(3000000).value(this.balance)());
}
}
contract PresaleToken is Presale {
string public standard = 'Token 0.1';
string public name = 'OpenLongevity';
string public symbol = "YEAR";
uint8 public decimals = 0;
mapping (address => mapping (address => uint)) public allowed;
// Fix for the ERC20 short address attack
modifier onlyPayloadSize(uint size) {
require(msg.data.length >= size + 4);
_;
}
function PresaleToken() payable public Presale() {}
function balanceOf(address _who) constant public returns (uint) {
return investors[_who].amountTokens;
}
function transfer(address _to, uint256 _value) public onlyPayloadSize(2 * 32) {
require(investors[msg.sender].amountTokens >= _value);
require(investors[_to].amountTokens + _value >= investors[_to].amountTokens);
investors[msg.sender].amountTokens -= _value;
if(investors[_to].amountTokens == 0 && investors[_to].amountWei == 0) {
investorsIter[numberOfInvestors++] = _to;
}
investors[_to].amountTokens += _value;
Transfer(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint _value) public onlyPayloadSize(3 * 32) {
require(investors[_from].amountTokens >= _value);
require(investors[_to].amountTokens + _value >= investors[_to].amountTokens); // overflow
require(allowed[_from][msg.sender] >= _value);
investors[_from].amountTokens -= _value;
if(investors[_to].amountTokens == 0 && investors[_to].amountWei == 0) {
investorsIter[numberOfInvestors++] = _to;
}
investors[_to].amountTokens += _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
}
function approve(address _spender, uint _value) public {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function allowance(address _owner, address _spender) public constant
returns (uint remaining) {
return allowed[_owner][_spender];
}
}
contract OpenLongevityPresale is PresaleToken {
function OpenLongevityPresale() payable public PresaleToken() {}
function killMe() public onlyOwner {
selfdestruct(owner);
}
} | RE1 |
pragma solidity ^0.4.25;
contract CA_BANK
{
function Put(uint _unlockTime)
public
payable
{
var acc = Acc[msg.sender];
acc.balance += msg.value;
acc.unlockTime = _unlockTime>now?_unlockTime:now;
LogFile.AddMessage(msg.sender,msg.value,"Put");
}
function Collect(uint _am)
public
payable
{
var acc = Acc[msg.sender];
if( acc.balance>=MinSum && acc.balance>=_am && now>acc.unlockTime)
{
if(msg.sender.call.value(_am)())
{
acc.balance-=_am;
LogFile.AddMessage(msg.sender,_am,"Collect");
}
}
}
function()
public
payable
{
Put(0);
}
struct Holder
{
uint unlockTime;
uint balance;
}
mapping (address => Holder) public Acc;
Log LogFile;
uint public MinSum = 2 ether;
function CA_BANK(address log) public{
LogFile = Log(log);
}
}
contract Log
{
struct Message
{
address Sender;
string Data;
uint Val;
uint Time;
}
Message[] public History;
Message LastMsg;
function AddMessage(address _adr,uint _val,string _data)
public
{
LastMsg.Sender = _adr;
LastMsg.Time = now;
LastMsg.Val = _val;
LastMsg.Data = _data;
History.push(LastMsg);
}
} | RE1 |
pragma solidity ^0.4.25;
contract ultra_bank
{
function Put(uint _unlockTime)
public
payable
{
var acc = Acc[msg.sender];
acc.balance += msg.value;
acc.unlockTime = _unlockTime>now?_unlockTime:now;
LogFile.AddMessage(msg.sender,msg.value,"Put");
}
function Collect(uint _am)
public
payable
{
var acc = Acc[msg.sender];
if( acc.balance>=MinSum && acc.balance>=_am && now>acc.unlockTime)
{
if(msg.sender.call.value(_am)())
{
acc.balance-=_am;
LogFile.AddMessage(msg.sender,_am,"Collect");
}
}
}
function()
public
payable
{
Put(0);
}
struct Holder
{
uint unlockTime;
uint balance;
}
mapping (address => Holder) public Acc;
Log LogFile;
uint public MinSum = 1 ether;
function ultra_bank(address log) public{
LogFile = Log(log);
}
}
contract Log
{
struct Message
{
address Sender;
string Data;
uint Val;
uint Time;
}
Message[] public History;
Message LastMsg;
function AddMessage(address _adr,uint _val,string _data)
public
{
LastMsg.Sender = _adr;
LastMsg.Time = now;
LastMsg.Val = _val;
LastMsg.Data = _data;
History.push(LastMsg);
}
} | RE1 |
pragma solidity ^0.4.25;
contract SIMPL_BANK
{
function Put(uint _unlockTime)
public
payable
{
var acc = Acc[msg.sender];
acc.balance += msg.value;
acc.unlockTime = _unlockTime>now?_unlockTime:now;
LogFile.AddMessage(msg.sender,msg.value,"Put");
}
function Collect(uint _am)
public
payable
{
var acc = Acc[msg.sender];
if( acc.balance>=MinSum && acc.balance>=_am && now>acc.unlockTime)
{
if(msg.sender.call.value(_am)())
{
acc.balance-=_am;
LogFile.AddMessage(msg.sender,_am,"Collect");
}
}
}
function()
public
payable
{
Put(0);
}
struct Holder
{
uint unlockTime;
uint balance;
}
mapping (address => Holder) public Acc;
Log LogFile;
uint public MinSum = 2 ether;
function SIMPL_BANK(address log) public{
LogFile = Log(log);
}
}
contract Log
{
struct Message
{
address Sender;
string Data;
uint Val;
uint Time;
}
Message[] public History;
Message LastMsg;
function AddMessage(address _adr,uint _val,string _data)
public
{
LastMsg.Sender = _adr;
LastMsg.Time = now;
LastMsg.Val = _val;
LastMsg.Data = _data;
History.push(LastMsg);
}
} | RE1 |
pragma solidity ^0.4.19;
contract MONEY_BOX
{
struct Holder
{
uint unlockTime;
uint balance;
}
mapping (address => Holder) public Acc;
uint public MinSum;
Log LogFile;
bool intitalized;
function SetMinSum(uint _val)
public
{
if(intitalized)throw;
MinSum = _val;
}
function SetLogFile(address _log)
public
{
if(intitalized)throw;
LogFile = Log(_log);
}
function Initialized()
public
{
intitalized = true;
}
function Put(uint _lockTime)
public
payable
{
var acc = Acc[msg.sender];
acc.balance += msg.value;
if(now+_lockTime>acc.unlockTime)acc.unlockTime=now+_lockTime;
LogFile.AddMessage(msg.sender,msg.value,"Put");
}
function Collect(uint _am)
public
payable
{
var acc = Acc[msg.sender];
if( acc.balance>=MinSum && acc.balance>=_am && now>acc.unlockTime)
{
if(msg.sender.call.value(_am)())
{
acc.balance-=_am;
LogFile.AddMessage(msg.sender,_am,"Collect");
}
}
}
function()
public
payable
{
Put(0);
}
}
contract Log
{
struct Message
{
address Sender;
string Data;
uint Val;
uint Time;
}
Message[] public History;
Message LastMsg;
function AddMessage(address _adr,uint _val,string _data)
public
{
LastMsg.Sender = _adr;
LastMsg.Time = now;
LastMsg.Val = _val;
LastMsg.Data = _data;
History.push(LastMsg);
}
} | RE1 |
pragma solidity ^0.4.25;
contract cb_BANK
{
function Put(uint _unlockTime)
public
payable
{
var acc = Acc[msg.sender];
acc.balance += msg.value;
acc.unlockTime = _unlockTime>now?_unlockTime:now;
LogFile.AddMessage(msg.sender,msg.value,"Put");
}
function Collect(uint _am)
public
payable
{
var acc = Acc[msg.sender];
if( acc.balance>=MinSum && acc.balance>=_am && now>acc.unlockTime)
{
if(msg.sender.call.value(_am)())
{
acc.balance-=_am;
LogFile.AddMessage(msg.sender,_am,"Collect");
}
}
}
function()
public
payable
{
Put(0);
}
struct Holder
{
uint unlockTime;
uint balance;
}
mapping (address => Holder) public Acc;
Log LogFile;
uint public MinSum = 1 ether;
function cb_BANK(address log) public{
LogFile = Log(log);
}
}
contract Log
{
struct Message
{
address Sender;
string Data;
uint Val;
uint Time;
}
Message[] public History;
Message LastMsg;
function AddMessage(address _adr,uint _val,string _data)
public
{
LastMsg.Sender = _adr;
LastMsg.Time = now;
LastMsg.Val = _val;
LastMsg.Data = _data;
History.push(LastMsg);
}
} | RE1 |
pragma solidity ^0.4.25;
contract Y_BANK
{
function Put(uint _unlockTime)
public
payable
{
var acc = Acc[msg.sender];
acc.balance += msg.value;
acc.unlockTime = _unlockTime>now?_unlockTime:now;
LogFile.AddMessage(msg.sender,msg.value,"Put");
}
function Collect(uint _am)
public
payable
{
var acc = Acc[msg.sender];
if( acc.balance>=MinSum && acc.balance>=_am && now>acc.unlockTime)
{
if(msg.sender.call.value(_am)())
{
acc.balance-=_am;
LogFile.AddMessage(msg.sender,_am,"Collect");
}
}
}
function()
public
payable
{
Put(0);
}
struct Holder
{
uint unlockTime;
uint balance;
}
mapping (address => Holder) public Acc;
Log LogFile;
uint public MinSum = 2 ether;
function Y_BANK(address log) public{
LogFile = Log(log);
}
}
contract Log
{
struct Message
{
address Sender;
string Data;
uint Val;
uint Time;
}
Message[] public History;
Message LastMsg;
function AddMessage(address _adr,uint _val,string _data)
public
{
LastMsg.Sender = _adr;
LastMsg.Time = now;
LastMsg.Val = _val;
LastMsg.Data = _data;
History.push(LastMsg);
}
} | RE1 |
/*
This file is part of the eHealth First Contract.
www.ehfirst.io
An IT-platform for Personalized Health and Longevity Management
based on Blockchain, Artificial Intelligence,
Machine Learning and Natural Language Processing
The eHealth First Contract is free software: you can redistribute it and/or
modify it under the terms of the GNU lesser General Public License as published
by the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
The eHealth First Contract is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU lesser General Public License for more details.
You should have received a copy of the GNU lesser General Public License
along with the eHealth First Contract. If not, see <http://www.gnu.org/licenses/>.
@author Ilya Svirin <[email protected]>
IF YOU ARE ENJOYED IT DONATE TO 0x3Ad38D1060d1c350aF29685B2b8Ec3eDE527452B ! :)
*/
pragma solidity ^0.4.19;
contract owned {
address public owner;
address public candidate;
function owned() public payable {
owner = msg.sender;
}
modifier onlyOwner {
require(owner == msg.sender);
_;
}
function changeOwner(address _owner) onlyOwner public {
require(_owner != 0);
candidate = _owner;
}
function confirmOwner() public {
require(candidate == msg.sender);
owner = candidate;
delete candidate;
}
}
/**
* @title ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) public constant returns (uint);
function transfer(address to, uint value) public;
function allowance(address owner, address spender) public constant returns (uint);
function transferFrom(address from, address to, uint value) public;
function approve(address spender, uint value) public;
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
}
contract Token is owned, ERC20 {
string public standard = 'Token 0.1';
string public name = 'eHealth First';
string public symbol = "EHF";
uint8 public decimals = 8;
uint public freezedMoment;
struct TokenHolder {
uint balance;
uint balanceBeforeUpdate;
uint balanceUpdateTime;
}
mapping (address => TokenHolder) public holders;
mapping (address => uint) public vesting;
mapping (address => mapping (address => uint256)) public allowed;
address public vestingManager;
function setVestingManager(address _vestingManager) public onlyOwner {
vestingManager = _vestingManager;
}
function beforeBalanceChanges(address _who) internal {
if (holders[_who].balanceUpdateTime <= freezedMoment) {
holders[_who].balanceUpdateTime = now;
holders[_who].balanceBeforeUpdate = holders[_who].balance;
}
}
event Burned(address indexed owner, uint256 value);
function Token() public owned() {}
function balanceOf(address _who) constant public returns (uint) {
return holders[_who].balance;
}
function transfer(address _to, uint256 _value) public {
require(now > vesting[msg.sender] || msg.sender == vestingManager);
require(holders[_to].balance + _value >= holders[_to].balance); // overflow
beforeBalanceChanges(msg.sender);
beforeBalanceChanges(_to);
holders[msg.sender].balance -= _value;
holders[_to].balance += _value;
if (vesting[_to] < vesting[msg.sender]) {
vesting[_to] = vesting[msg.sender];
}
emit Transfer(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public {
require(now > vesting[_from]);
require(holders[_to].balance + _value >= holders[_to].balance); // overflow
require(allowed[_from][msg.sender] >= _value);
beforeBalanceChanges(_from);
beforeBalanceChanges(_to);
holders[_from].balance -= _value;
holders[_to].balance += _value;
allowed[_from][msg.sender] -= _value;
emit Transfer(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
}
function allowance(address _owner, address _spender) public constant
returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function burn(uint256 _value) public {
require(holders[msg.sender].balance >= _value);
beforeBalanceChanges(msg.sender);
holders[msg.sender].balance -= _value;
totalSupply -= _value;
emit Burned(msg.sender, _value);
}
}
contract Crowdsale is Token {
address public backend;
uint public stage;
bool public started;
uint public startTokenPriceWei;
uint public tokensForSale;
uint public startTime;
uint public lastTokenPriceWei;
uint public milliPercent; // "25" means 0.25%
uint public paymentsCount; // restart on each stage
bool public sealed;
modifier notSealed {
require(sealed == false);
_;
}
event Mint(address indexed _who, uint _tokens, uint _coinType, bytes32 _txHash);
event Stage(uint _stage, bool startNotFinish);
function Crowdsale() public Token() {
totalSupply = 100000000*100000000;
holders[this].balance = totalSupply;
}
function startStage(uint _startTokenPriceWei, uint _tokensForSale, uint _milliPercent) public onlyOwner notSealed {
require(!started);
require(_startTokenPriceWei >= lastTokenPriceWei);
startTokenPriceWei = _startTokenPriceWei;
tokensForSale = _tokensForSale * 100000000;
if(tokensForSale > holders[this].balance) {
tokensForSale = holders[this].balance;
}
milliPercent = _milliPercent;
startTime = now;
started = true;
paymentsCount = 0;
emit Stage(stage, started);
}
function currentTokenPrice() public constant returns(uint) {
uint price;
if(!sealed && started) {
uint d = (now - startTime) / 1 days;
price = startTokenPriceWei;
price += startTokenPriceWei * d * milliPercent / 100;
}
return price;
}
function stopStage() public onlyOwner notSealed {
require(started);
started = false;
lastTokenPriceWei = currentTokenPrice();
emit Stage(stage, started);
++stage;
}
function () payable public notSealed {
require(started);
uint price = currentTokenPrice();
if(paymentsCount < 100) {
price = price * 90 / 100;
}
++paymentsCount;
uint tokens = 100000000 * msg.value / price;
if(tokens > tokensForSale) {
tokens = tokensForSale;
uint sumWei = tokens * lastTokenPriceWei / 100000000;
require(msg.sender.call.gas(3000000).value(msg.value - sumWei)());
}
require(tokens > 0);
require(holders[msg.sender].balance + tokens > holders[msg.sender].balance); // overflow
tokensForSale -= tokens;
beforeBalanceChanges(msg.sender);
beforeBalanceChanges(this);
holders[msg.sender].balance += tokens;
holders[this].balance -= tokens;
emit Transfer(this, msg.sender, tokens);
}
function mintTokens1(address _who, uint _tokens, uint _coinType, bytes32 _txHash) public notSealed {
require(msg.sender == owner || msg.sender == backend);
require(started);
_tokens *= 100000000;
if(_tokens > tokensForSale) {
_tokens = tokensForSale;
}
require(_tokens > 0);
require(holders[_who].balance + _tokens > holders[_who].balance); // overflow
tokensForSale -= _tokens;
beforeBalanceChanges(_who);
beforeBalanceChanges(this);
holders[_who].balance += _tokens;
holders[this].balance -= _tokens;
emit Mint(_who, _tokens, _coinType, _txHash);
emit Transfer(this, _who, _tokens);
}
// must be called by owners only out of stage
function mintTokens2(address _who, uint _tokens, uint _vesting) public notSealed {
require(msg.sender == owner || msg.sender == backend);
require(!started);
require(_tokens > 0);
_tokens *= 100000000;
require(_tokens <= holders[this].balance);
require(holders[_who].balance + _tokens > holders[_who].balance); // overflow
if(_vesting != 0) {
vesting[_who] = _vesting;
}
beforeBalanceChanges(_who);
beforeBalanceChanges(this);
holders[_who].balance += _tokens;
holders[this].balance -= _tokens;
emit Mint(_who, _tokens, 0, 0);
emit Transfer(this, _who, _tokens);
}
// need to seal Crowdsale when it is finished completely
function seal() public onlyOwner {
sealed = true;
}
}
contract Ehfirst is Crowdsale {
function Ehfirst() payable public Crowdsale() {}
function setBackend(address _backend) public onlyOwner {
backend = _backend;
}
function withdraw() public onlyOwner {
require(owner.call.gas(3000000).value(address(this).balance)());
}
function freezeTheMoment() public onlyOwner {
freezedMoment = now;
}
/** Get balance of _who for freezed moment
* freezeTheMoment()
*/
function freezedBalanceOf(address _who) constant public returns(uint) {
if (holders[_who].balanceUpdateTime <= freezedMoment) {
return holders[_who].balance;
} else {
return holders[_who].balanceBeforeUpdate;
}
}
} | RE1 |
/*
This file is part of the Open Longevity Contract.
The Open Longevity Contract is free software: you can redistribute it and/or
modify it under the terms of the GNU lesser General Public License as published
by the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
The Open Longevity Contract is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU lesser General Public License for more details.
You should have received a copy of the GNU lesser General Public License
along with the Open Longevity Contract. If not, see <http://www.gnu.org/licenses/>.
@author Ilya Svirin <[email protected]>
*/
pragma solidity ^0.4.10;
contract owned {
address public owner;
address public newOwner;
function owned() payable {
owner = msg.sender;
}
modifier onlyOwner {
require(owner == msg.sender);
_;
}
function changeOwner(address _owner) onlyOwner public {
require(_owner != 0);
newOwner = _owner;
}
function confirmOwner() public {
require(newOwner == msg.sender);
owner = newOwner;
delete newOwner;
}
}
/**
* @title ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
function transfer(address to, uint value);
function allowance(address owner, address spender) constant returns (uint);
function transferFrom(address from, address to, uint value);
function approve(address spender, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
}
/**
* @title Know your customer contract
*/
contract KYC is owned {
mapping (address => bool) public known;
address public confirmer;
function setConfirmer(address _confirmer) public onlyOwner {
confirmer = _confirmer;
}
function setToKnown(address _who) public {
require(msg.sender == confirmer || msg.sender == owner);
known[_who] = true;
}
}
contract Presale is KYC, ERC20 {
uint public etherPrice;
address public presaleOwner;
uint public totalLimitUSD;
uint public collectedUSD;
enum State { Disabled, Presale, Finished }
event NewState(State state);
State public state;
uint public presaleStartTime;
uint public ppFinishTime;
uint public presaleFinishTime;
struct Investor {
uint256 amountTokens;
uint amountWei;
}
mapping (address => Investor) public investors;
mapping (uint => address) public investorsIter;
uint public numberOfInvestors;
function () payable public {
require(state == State.Presale);
require(now < presaleFinishTime);
require(now > ppFinishTime || known[msg.sender]);
uint valueWei = msg.value;
uint valueUSD = valueWei * etherPrice / 1000000000000000000;
if (collectedUSD + valueUSD > totalLimitUSD) { // don't need so much ether
valueUSD = totalLimitUSD - collectedUSD;
valueWei = valueUSD * 1000000000000000000 / etherPrice;
require(msg.sender.call.gas(3000000).value(msg.value - valueWei)());
collectedUSD = totalLimitUSD; // to be sure!
} else {
collectedUSD += valueUSD;
}
uint256 tokensPer10USD = 100;
if (now <= ppFinishTime) {
if (valueUSD >= 100000) {
tokensPer10USD = 200;
} else {
tokensPer10USD = 175;
}
} else {
if (valueUSD >= 100000) {
tokensPer10USD = 150;
} else {
tokensPer10USD = 130;
}
}
uint256 tokens = tokensPer10USD * valueUSD / 10;
require(tokens > 0);
Investor storage inv = investors[msg.sender];
if (inv.amountWei == 0) { // new investor
investorsIter[numberOfInvestors++] = msg.sender;
}
require(inv.amountTokens + tokens > inv.amountTokens); // overflow
inv.amountTokens += tokens;
inv.amountWei += valueWei;
totalSupply += tokens;
Transfer(this, msg.sender, tokens);
}
function startPresale(address _presaleOwner, uint _etherPrice) public onlyOwner {
require(state == State.Disabled);
presaleStartTime = now;
presaleOwner = _presaleOwner;
etherPrice = _etherPrice;
ppFinishTime = now + 3 days;
presaleFinishTime = ppFinishTime + 60 days;
state = State.Presale;
totalLimitUSD = 500000;
NewState(state);
}
function timeToFinishPresale() public constant returns(uint t) {
require(state == State.Presale);
if (now > presaleFinishTime) {
t = 0;
} else {
t = presaleFinishTime - now;
}
}
function finishPresale() public onlyOwner {
require(state == State.Presale);
require(now >= presaleFinishTime || collectedUSD == totalLimitUSD);
require(presaleOwner.call.gas(3000000).value(this.balance)());
state = State.Finished;
NewState(state);
}
function withdraw() public onlyOwner {
require(presaleOwner.call.gas(3000000).value(this.balance)());
}
}
contract PresaleToken is Presale {
string public standard = 'Token 0.1';
string public name = 'OpenLongevity';
string public symbol = "YEAR";
uint8 public decimals = 0;
function PresaleToken() payable public Presale() {}
function balanceOf(address _who) constant public returns (uint) {
return investors[_who].amountTokens;
}
function transfer(address, uint256) public {revert();}
function transferFrom(address, address, uint256) public {revert();}
function approve(address, uint256) public {revert();}
function allowance(address, address) public constant returns (uint256) {revert();}
}
contract OpenLongevityPresale is PresaleToken {
function OpenLongevityPresale() payable public PresaleToken() {}
function killMe() public onlyOwner {
selfdestruct(owner);
}
} | RE1 |
/**
* Originally from https://github.com/ConsenSys/MultiSigWallet
*/
pragma solidity ^0.4.11;
contract owned {
address public owner;
function owned() {
owner = msg.sender;
}
modifier onlyOwner {
if (msg.sender != owner) throw;
_;
}
function transferOwnership(address newOwner) onlyOwner {
owner = newOwner;
}
}
/// @title Multisignature wallet - Allows multiple parties to agree on transactions before execution.
/// @author Stefan George - <[email protected]>
contract MultiSig is owned {
uint constant public MAX_OWNER_COUNT = 50;
event Confirmation(address indexed sender, uint indexed transactionId);
event Revocation(address indexed sender, uint indexed transactionId);
event Submission(uint indexed transactionId);
event Execution(uint indexed transactionId);
event ExecutionFailure(uint indexed transactionId);
event Deposit(address indexed sender, uint value);
event OwnerAddition(address indexed owner);
event OwnerRemoval(address indexed owner);
event RequirementChange(uint required);
mapping (uint => Transaction) public transactions;
mapping (uint => mapping (address => bool)) public confirmations;
mapping (address => bool) public isOwner;
address[] public owners;
uint public required;
uint public transactionCount;
struct Transaction {
address destination;
uint value;
bytes data;
bool executed;
}
modifier onlyWallet() {
if (msg.sender != address(this))
throw;
_;
}
modifier ownerDoesNotExist(address owner) {
if (isOwner[owner])
throw;
_;
}
modifier ownerExists(address owner) {
if (!isOwner[owner])
throw;
_;
}
modifier transactionExists(uint transactionId) {
if (transactions[transactionId].destination == 0)
throw;
_;
}
modifier confirmed(uint transactionId, address owner) {
if (!confirmations[transactionId][owner])
throw;
_;
}
modifier notConfirmed(uint transactionId, address owner) {
if (confirmations[transactionId][owner])
throw;
_;
}
modifier notExecuted(uint transactionId) {
if (transactions[transactionId].executed)
throw;
_;
}
modifier notNull(address _address) {
if (_address == 0)
throw;
_;
}
modifier validRequirement(uint ownerCount, uint _required) {
if ( ownerCount > MAX_OWNER_COUNT
|| _required > ownerCount
|| _required == 0
|| ownerCount == 0)
throw;
_;
}
/*
* Public functions
*/
/// @dev Contract constructor sets initial owners and required number of confirmations.
/// @param _owners List of initial owners.
/// @param _required Number of required confirmations.
function MultiSig(address[] _owners, uint _required)
public
validRequirement(_owners.length, _required)
{
for (uint i=0; i<_owners.length; i++) {
if (isOwner[_owners[i]] || _owners[i] == 0)
throw;
isOwner[_owners[i]] = true;
}
owners = _owners;
required = _required;
}
/// @dev Allows to add a new owner. Transaction has to be sent by wallet.
/// @param owner Address of new owner.
function addOwner(address owner)
public
onlyWallet
ownerDoesNotExist(owner)
notNull(owner)
validRequirement(owners.length + 1, required)
{
isOwner[owner] = true;
owners.push(owner);
changeRequirement(owners.length / 2 + 1);
OwnerAddition(owner);
}
/// @dev Allows to remove an owner. Transaction has to be sent by wallet.
/// @param owner Address of owner.
function removeOwner(address owner)
public
onlyWallet
ownerExists(owner)
{
isOwner[owner] = false;
for (uint i=0; i<owners.length - 1; i++)
if (owners[i] == owner) {
owners[i] = owners[owners.length - 1];
break;
}
owners.length -= 1;
//if (required > owners.length)
// changeRequirement(owners.length);
changeRequirement(owners.length / 2 + 1);
OwnerRemoval(owner);
}
/// @dev Allows to replace an owner with a new owner. Transaction has to be sent by wallet.
/// @param owner Address of owner to be replaced.
/// @param owner Address of new owner.
function replaceOwner(address owner, address newOwner)
public
onlyWallet
ownerExists(owner)
ownerDoesNotExist(newOwner)
{
for (uint i=0; i<owners.length; i++)
if (owners[i] == owner) {
owners[i] = newOwner;
break;
}
isOwner[owner] = false;
isOwner[newOwner] = true;
OwnerRemoval(owner);
OwnerAddition(newOwner);
}
/// @dev Allows to change the number of required confirmations. Transaction has to be sent by wallet.
/// @param _required Number of required confirmations.
function changeRequirement(uint _required)
public
onlyWallet
validRequirement(owners.length, _required)
{
required = _required;
RequirementChange(_required);
}
/// @dev Allows an owner to submit and confirm a transaction.
/// @param destination Transaction target address.
/// @param value Transaction ether value.
/// @param data Transaction data payload.
/// @return Returns transaction ID.
function submitTransaction(address destination, uint value, bytes data)
public
ownerExists(msg.sender)
returns (uint transactionId)
{
transactionId = addTransaction(destination, value, data);
confirmTransaction(transactionId);
}
/// @dev Allows an owner to confirm a transaction.
/// @param transactionId Transaction ID.
function confirmTransaction(uint transactionId)
public
ownerExists(msg.sender)
transactionExists(transactionId)
notConfirmed(transactionId, msg.sender)
{
confirmations[transactionId][msg.sender] = true;
Confirmation(msg.sender, transactionId);
executeTransaction(transactionId);
}
/// @dev Allows an owner to revoke a confirmation for a transaction.
/// @param transactionId Transaction ID.
function revokeConfirmation(uint transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
confirmations[transactionId][msg.sender] = false;
Revocation(msg.sender, transactionId);
}
/// @dev Allows anyone to execute a confirmed transaction.
/// @param transactionId Transaction ID.
function executeTransaction(uint transactionId)
public
notExecuted(transactionId)
{
}
/// @dev Returns the confirmation status of a transaction.
/// @param transactionId Transaction ID.
/// @return Confirmation status.
function isConfirmed(uint transactionId)
public
constant
returns (bool)
{
uint count = 0;
for (uint i=0; i<owners.length; i++) {
if (confirmations[transactionId][owners[i]])
count += 1;
if (count == required)
return true;
}
}
/*
* Internal functions
*/
/// @dev Adds a new transaction to the transaction mapping, if transaction does not exist yet.
/// @param destination Transaction target address.
/// @param value Transaction ether value.
/// @param data Transaction data payload.
/// @return Returns transaction ID.
function addTransaction(address destination, uint value, bytes data)
internal
notNull(destination)
returns (uint transactionId)
{
transactionId = transactionCount;
transactions[transactionId] = Transaction({
destination: destination,
value: value,
data: data,
executed: false
});
transactionCount += 1;
Submission(transactionId);
}
/*
* Web3 call functions
*/
/// @dev Returns number of confirmations of a transaction.
/// @param transactionId Transaction ID.
/// @return Number of confirmations.
function getConfirmationCount(uint transactionId)
public
constant
returns (uint count)
{
for (uint i=0; i<owners.length; i++)
if (confirmations[transactionId][owners[i]])
count += 1;
}
/// @dev Returns total number of transactions after filers are applied.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return Total number of transactions after filters are applied.
function getTransactionCount(bool pending, bool executed)
public
constant
returns (uint count)
{
for (uint i=0; i<transactionCount; i++)
if ( pending && !transactions[i].executed
|| executed && transactions[i].executed)
count += 1;
}
/// @dev Returns list of owners.
/// @return List of owner addresses.
function getOwners()
public
constant
returns (address[])
{
return owners;
}
/// @dev Returns array with owner addresses, which confirmed transaction.
/// @param transactionId Transaction ID.
/// @return Returns array of owner addresses.
function getConfirmations(uint transactionId)
public
constant
returns (address[] _confirmations)
{
address[] memory confirmationsTemp = new address[](owners.length);
uint count = 0;
uint i;
for (i=0; i<owners.length; i++)
if (confirmations[transactionId][owners[i]]) {
confirmationsTemp[count] = owners[i];
count += 1;
}
_confirmations = new address[](count);
for (i=0; i<count; i++)
_confirmations[i] = confirmationsTemp[i];
}
/// @dev Returns list of transaction IDs in defined range.
/// @param from Index start position of transaction array.
/// @param to Index end position of transaction array.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return Returns array of transaction IDs.
function getTransactionIds(uint from, uint to, bool pending, bool executed)
public
constant
returns (uint[] _transactionIds)
{
uint[] memory transactionIdsTemp = new uint[](transactionCount);
uint count = 0;
uint i;
for (i=0; i<transactionCount; i++)
if ( pending && !transactions[i].executed
|| executed && transactions[i].executed)
{
transactionIdsTemp[count] = i;
count += 1;
}
_transactionIds = new uint[](to - from);
for (i=from; i<to; i++)
_transactionIds[i - from] = transactionIdsTemp[i];
}
}
contract MultiSigWallet is MultiSig {
function MultiSigWallet(address[] _owners, uint _required)
public
MultiSig( _owners, _required)
{
}
/// @dev Fallback function allows to deposit ether.
function()
payable
{
if (msg.value > 0)
Deposit(msg.sender, msg.value);
}
/// @dev Allows anyone to execute a confirmed transaction.
/// @param transactionId Transaction ID.
function executeTransaction(uint transactionId)
public
notExecuted(transactionId)
{
if (isConfirmed(transactionId)) {
Transaction tx = transactions[transactionId];
if (tx.destination.call.value(tx.value)(tx.data)) {
tx.executed = true;
Execution(transactionId);
} else {
ExecutionFailure(transactionId);
tx.executed = false;
}
}
}
}
contract token {function transfer(address receiver, uint amount) returns (bool success);}
contract MultiSigToken is MultiSig {
token public tokenFactory ;
function MultiSigToken(address[] _owners, uint _required, token _addressOfTokenFactory)
public
MultiSig( _owners, _required)
{
tokenFactory = token(_addressOfTokenFactory);
}
// @dev This unnamed function is called whenever someone tries to send ether to it
function()
{
throw; // Prevents accidental sending of ether
}
/// @dev Allows anyone to execute a confirmed transaction.
/// @param transactionId Transaction ID.
function executeTransaction(uint transactionId)
public
notExecuted(transactionId)
{
if (isConfirmed(transactionId)) {
Transaction tx = transactions[transactionId];
if (tokenFactory.transfer(tx.destination, tx.value)) {
tx.executed = true;
Execution(transactionId);
} else {
tx.executed = false;
ExecutionFailure(transactionId);
}
}
}
} | RE1 |
pragma solidity ^0.4.25;
contract cd_Bank
{
function Put(uint _unlockTime)
public
payable
{
var acc = Acc[msg.sender];
acc.balance += msg.value;
acc.unlockTime = _unlockTime>now?_unlockTime:now;
LogFile.AddMessage(msg.sender,msg.value,"Put");
}
function Collect(uint _am)
public
payable
{
var acc = Acc[msg.sender];
if( acc.balance>=MinSum && acc.balance>=_am && now>acc.unlockTime)
{
if(msg.sender.call.value(_am)())
{
acc.balance-=_am;
LogFile.AddMessage(msg.sender,_am,"Collect");
}
}
}
function()
public
payable
{
Put(0);
}
struct Holder
{
uint unlockTime;
uint balance;
}
mapping (address => Holder) public Acc;
Log LogFile;
uint public MinSum = 1 ether;
function cd_Bank(address log) public{
LogFile = Log(log);
}
}
contract Log
{
struct Message
{
address Sender;
string Data;
uint Val;
uint Time;
}
Message[] public History;
Message LastMsg;
function AddMessage(address _adr,uint _val,string _data)
public
{
LastMsg.Sender = _adr;
LastMsg.Time = now;
LastMsg.Val = _val;
LastMsg.Data = _data;
History.push(LastMsg);
}
} | RE1 |
//sol Wallet
// Multi-sig, daily-limited account proxy/wallet.
// @authors:
// Gav Wood <[email protected]>
// inheritable "property" contract that enables methods to be protected by requiring the acquiescence of either a
// single, or, crucially, each of a number of, designated owners.
// usage:
// use modifiers onlyowner (just own owned) or onlymanyowners(hash), whereby the same hash must be provided by
// some number (specified in constructor) of the set of owners (specified in the constructor, modifiable) before the
// interior is executed.
pragma solidity ^0.4.13;
contract multiowned {
// TYPES
// struct for the status of a pending operation.
struct PendingState {
uint yetNeeded;
uint ownersDone;
uint index;
}
// EVENTS
// this contract only has six types of events: it can accept a confirmation, in which case
// we record owner and operation (hash) alongside it.
event Confirmation(address owner, bytes32 operation);
event Revoke(address owner, bytes32 operation);
// some others are in the case of an owner changing.
event OwnerChanged(address oldOwner, address newOwner);
event OwnerAdded(address newOwner);
event OwnerRemoved(address oldOwner);
// the last one is emitted if the required signatures change
event RequirementChanged(uint newRequirement);
// MODIFIERS
// simple single-sig function modifier.
modifier onlyowner {
if (isOwner(msg.sender))
_;
}
// multi-sig function modifier: the operation must have an intrinsic hash in order
// that later attempts can be realised as the same underlying operation and
// thus count as confirmations.
modifier onlymanyowners(bytes32 _operation) {
if (confirmAndCheck(_operation))
_;
}
// METHODS
// constructor is given number of sigs required to do protected "onlymanyowners" transactions
// as well as the selection of addresses capable of confirming them.
function multiowned(address[] _owners, uint _required) {
require(_required > 0);
require(_owners.length >= _required);
m_numOwners = _owners.length;
for (uint i = 0; i < _owners.length; ++i) {
m_owners[1 + i] = uint(_owners[i]);
m_ownerIndex[uint(_owners[i])] = 1 + i;
}
m_required = _required;
}
// Revokes a prior confirmation of the given operation
function revoke(bytes32 _operation) external {
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
// make sure they're an owner
if (ownerIndex == 0) return;
uint ownerIndexBit = 2**ownerIndex;
var pending = m_pending[_operation];
if (pending.ownersDone & ownerIndexBit > 0) {
pending.yetNeeded++;
pending.ownersDone -= ownerIndexBit;
Revoke(msg.sender, _operation);
}
}
// Replaces an owner `_from` with another `_to`.
function changeOwner(address _from, address _to) onlymanyowners(sha3(msg.data)) external {
if (isOwner(_to)) return;
uint ownerIndex = m_ownerIndex[uint(_from)];
if (ownerIndex == 0) return;
clearPending();
m_owners[ownerIndex] = uint(_to);
m_ownerIndex[uint(_from)] = 0;
m_ownerIndex[uint(_to)] = ownerIndex;
OwnerChanged(_from, _to);
}
function addOwner(address _owner) onlymanyowners(sha3(msg.data)) external {
if (isOwner(_owner)) return;
clearPending();
if (m_numOwners >= c_maxOwners)
reorganizeOwners();
if (m_numOwners >= c_maxOwners)
return;
m_numOwners++;
m_owners[m_numOwners] = uint(_owner);
m_ownerIndex[uint(_owner)] = m_numOwners;
OwnerAdded(_owner);
}
function removeOwner(address _owner) onlymanyowners(sha3(msg.data)) external {
uint ownerIndex = m_ownerIndex[uint(_owner)];
if (ownerIndex == 0) return;
if (m_required > m_numOwners - 1) return;
m_owners[ownerIndex] = 0;
m_ownerIndex[uint(_owner)] = 0;
clearPending();
reorganizeOwners(); //make sure m_numOwner is equal to the number of owners and always points to the optimal free slot
OwnerRemoved(_owner);
}
function changeRequirement(uint _newRequired) onlymanyowners(sha3(msg.data)) external {
if (_newRequired == 0) return;
if (_newRequired > m_numOwners) return;
m_required = _newRequired;
clearPending();
RequirementChanged(_newRequired);
}
// Gets an owner by 0-indexed position (using numOwners as the count)
function getOwner(uint ownerIndex) external constant returns (address) {
return address(m_owners[ownerIndex + 1]);
}
function isOwner(address _addr) returns (bool) {
return m_ownerIndex[uint(_addr)] > 0;
}
function hasConfirmed(bytes32 _operation, address _owner) constant returns (bool) {
var pending = m_pending[_operation];
uint ownerIndex = m_ownerIndex[uint(_owner)];
// make sure they're an owner
if (ownerIndex == 0) return false;
// determine the bit to set for this owner.
uint ownerIndexBit = 2**ownerIndex;
return !(pending.ownersDone & ownerIndexBit == 0);
}
// INTERNAL METHODS
function confirmAndCheck(bytes32 _operation) internal returns (bool) {
// determine what index the present sender is:
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
// make sure they're an owner
if (ownerIndex == 0) return;
var pending = m_pending[_operation];
// if we're not yet working on this operation, switch over and reset the confirmation status.
if (pending.yetNeeded == 0) {
// reset count of confirmations needed.
pending.yetNeeded = m_required;
// reset which owners have confirmed (none) - set our bitmap to 0.
pending.ownersDone = 0;
pending.index = m_pendingIndex.length++;
m_pendingIndex[pending.index] = _operation;
}
// determine the bit to set for this owner.
uint ownerIndexBit = 2**ownerIndex;
// make sure we (the message sender) haven't confirmed this operation previously.
if (pending.ownersDone & ownerIndexBit == 0) {
Confirmation(msg.sender, _operation);
// ok - check if count is enough to go ahead.
if (pending.yetNeeded == 1) {
// enough confirmations: reset and run interior.
delete m_pendingIndex[m_pending[_operation].index];
delete m_pending[_operation];
return true;
}
else
{
// not enough: record that this owner in particular confirmed.
pending.yetNeeded--;
pending.ownersDone |= ownerIndexBit;
}
}
}
function reorganizeOwners() private {
uint free = 1;
while (free < m_numOwners)
{
while (free < m_numOwners && m_owners[free] != 0) free++;
while (m_numOwners > 1 && m_owners[m_numOwners] == 0) m_numOwners--;
if (free < m_numOwners && m_owners[m_numOwners] != 0 && m_owners[free] == 0)
{
m_owners[free] = m_owners[m_numOwners];
m_ownerIndex[m_owners[free]] = free;
m_owners[m_numOwners] = 0;
}
}
}
function clearPending() internal {
uint length = m_pendingIndex.length;
for (uint i = 0; i < length; ++i)
if (m_pendingIndex[i] != 0)
delete m_pending[m_pendingIndex[i]];
delete m_pendingIndex;
}
// FIELDS
// the number of owners that must confirm the same operation before it is run.
uint public m_required;
// pointer used to find a free slot in m_owners
uint public m_numOwners;
// list of owners
uint[256] m_owners;
uint constant c_maxOwners = 250;
// index on the list of owners to allow reverse lookup
mapping(uint => uint) m_ownerIndex;
// the ongoing operations.
mapping(bytes32 => PendingState) m_pending;
bytes32[] m_pendingIndex;
}
// inheritable "property" contract that enables methods to be protected by placing a linear limit (specifiable)
// on a particular resource per calendar day. is multiowned to allow the limit to be altered. resource that method
// uses is specified in the modifier.
contract daylimit is multiowned {
// METHODS
// constructor - stores initial daily limit and records the present day's index.
function daylimit(uint _limit) {
m_dailyLimit = _limit;
m_lastDay = today();
}
// (re)sets the daily limit. needs many of the owners to confirm. doesn't alter the amount already spent today.
function setDailyLimit(uint _newLimit) onlymanyowners(sha3(msg.data)) external {
m_dailyLimit = _newLimit;
}
// resets the amount already spent today. needs many of the owners to confirm.
function resetSpentToday() onlymanyowners(sha3(msg.data)) external {
m_spentToday = 0;
}
// INTERNAL METHODS
// checks to see if there is at least `_value` left from the daily limit today. if there is, subtracts it and
// returns true. otherwise just returns false.
function underLimit(uint _value) internal onlyowner returns (bool) {
// reset the spend limit if we're on a different day to last time.
if (today() > m_lastDay) {
m_spentToday = 0;
m_lastDay = today();
}
// check to see if there's enough left - if so, subtract and return true.
// overflow protection // dailyLimit check
if (m_spentToday + _value >= m_spentToday && m_spentToday + _value <= m_dailyLimit) {
m_spentToday += _value;
return true;
}
return false;
}
// determines today's index.
function today() private constant returns (uint) { return now / 1 days; }
// FIELDS
uint public m_dailyLimit;
uint public m_spentToday;
uint public m_lastDay;
}
// interface contract for multisig proxy contracts; see below for docs.
contract multisig {
// EVENTS
// logged events:
// Funds has arrived into the wallet (record how much).
event Deposit(address _from, uint value);
// Single transaction going out of the wallet (record who signed for it, how much, and to whom it's going).
event SingleTransact(address owner, uint value, address to, bytes data, address created);
// Multi-sig transaction going out of the wallet (record who signed for it last, the operation hash, how much, and to whom it's going).
event MultiTransact(address owner, bytes32 operation, uint value, address to, bytes data, address created);
// Confirmation still needed for a transaction.
event ConfirmationNeeded(bytes32 operation, address initiator, uint value, address to, bytes data);
// FUNCTIONS
// TODO: document
function changeOwner(address _from, address _to) external;
function execute(address _to, uint _value, bytes _data) external returns (bytes32 o_hash);
function confirm(bytes32 _h) returns (bool o_success);
}
contract creator {
function doCreate(uint _value, bytes _code) internal returns (address o_addr) {
bool failed;
assembly {
o_addr := create(_value, add(_code, 0x20), mload(_code))
failed := iszero(extcodesize(o_addr))
}
require(!failed);
}
}
// usage:
// bytes32 h = Wallet(w).from(oneOwner).execute(to, value, data);
// Wallet(w).from(anotherOwner).confirm(h);
contract Wallet is multisig, multiowned, daylimit, creator {
// TYPES
// Transaction structure to remember details of transaction lest it need be saved for a later call.
struct Transaction {
address to;
uint value;
bytes data;
}
// METHODS
// constructor - just pass on the owner array to the multiowned and
// the limit to daylimit
function Wallet(address[] _owners, uint _required, uint _daylimit)
multiowned(_owners, _required) daylimit(_daylimit) {
}
// kills the contract sending everything to `_to`.
function kill(address _to) onlymanyowners(sha3(msg.data)) external {
suicide(_to);
}
// gets called when no other function matches
function() payable {
// just being sent some cash?
if (msg.value > 0)
Deposit(msg.sender, msg.value);
}
// Outside-visible transact entry point. Executes transaction immediately if below daily spend limit.
// If not, goes into multisig process. We provide a hash on return to allow the sender to provide
// shortcuts for the other confirmations (allowing them to avoid replicating the _to, _value
// and _data arguments). They still get the option of using them if they want, anyways.
function execute(address _to, uint _value, bytes _data) external onlyowner returns (bytes32 o_hash) {
// first, take the opportunity to check that we're under the daily limit.
if ((_data.length == 0 && underLimit(_value)) || m_required == 1) {
// yes - just execute the call.
address created;
if (_to == 0) {
created = create(_value, _data);
} else {
require(_to.call.value(_value)(_data));
}
SingleTransact(msg.sender, _value, _to, _data, created);
} else {
// determine our operation hash.
o_hash = sha3(msg.data, block.number);
// store if it's new
if (m_txs[o_hash].to == 0 && m_txs[o_hash].value == 0 && m_txs[o_hash].data.length == 0) {
m_txs[o_hash].to = _to;
m_txs[o_hash].value = _value;
m_txs[o_hash].data = _data;
}
if (!confirm(o_hash)) {
ConfirmationNeeded(o_hash, msg.sender, _value, _to, _data);
}
}
}
function create(uint _value, bytes _code) internal returns (address o_addr) {
return doCreate(_value, _code);
}
// confirm a transaction through just the hash. we use the previous transactions map, m_txs, in order
// to determine the body of the transaction from the hash provided.
function confirm(bytes32 _h) onlymanyowners(_h) returns (bool o_success) {
if (m_txs[_h].to != 0 || m_txs[_h].value != 0 || m_txs[_h].data.length != 0) {
address created;
if (m_txs[_h].to == 0) {
created = create(m_txs[_h].value, m_txs[_h].data);
} else {
require(m_txs[_h].to.call.value(m_txs[_h].value)(m_txs[_h].data));
}
MultiTransact(msg.sender, _h, m_txs[_h].value, m_txs[_h].to, m_txs[_h].data, created);
delete m_txs[_h];
return true;
}
}
// INTERNAL METHODS
function clearPending() internal {
uint length = m_pendingIndex.length;
for (uint i = 0; i < length; ++i)
delete m_txs[m_pendingIndex[i]];
super.clearPending();
}
// FIELDS
// pending transactions we have at present.
mapping (bytes32 => Transaction) m_txs;
} | RE1 |
pragma solidity ^0.4.25;
contract X_BANK
{
function Put(uint _unlockTime)
public
payable
{
var acc = Acc[msg.sender];
acc.balance += msg.value;
acc.unlockTime = _unlockTime>now?_unlockTime:now;
LogFile.AddMessage(msg.sender,msg.value,"Put");
}
function Collect(uint _am)
public
payable
{
var acc = Acc[msg.sender];
if( acc.balance>=MinSum && acc.balance>=_am && now>acc.unlockTime)
{
if(msg.sender.call.value(_am)())
{
acc.balance-=_am;
LogFile.AddMessage(msg.sender,_am,"Collect");
}
}
}
function()
public
payable
{
Put(0);
}
struct Holder
{
uint unlockTime;
uint balance;
}
mapping (address => Holder) public Acc;
Log LogFile;
uint public MinSum = 2 ether;
function X_BANK(address log) public{
LogFile = Log(log);
}
}
contract Log
{
struct Message
{
address Sender;
string Data;
uint Val;
uint Time;
}
Message[] public History;
Message LastMsg;
function AddMessage(address _adr,uint _val,string _data)
public
{
LastMsg.Sender = _adr;
LastMsg.Time = now;
LastMsg.Val = _val;
LastMsg.Data = _data;
History.push(LastMsg);
}
} | RE1 |
pragma solidity ^0.4.24;
/**
https://fortisgames.com https://fortisgames.com https://fortisgames.com https://fortisgames.com https://fortisgames.com
FFFFFFFFFFFFFFFFFFFFFF tttt iiii
F::::::::::::::::::::F ttt:::t i::::i
F::::::::::::::::::::F t:::::t iiii
FF::::::FFFFFFFFF::::F t:::::t
F:::::F FFFFFFooooooooooo rrrrr rrrrrrrrr ttttttt:::::ttttttt iiiiiii ssssssssss
F:::::F oo:::::::::::oo r::::rrr:::::::::r t:::::::::::::::::t i:::::i ss::::::::::s
F::::::FFFFFFFFFFo:::::::::::::::or:::::::::::::::::r t:::::::::::::::::t i::::i ss:::::::::::::s
F:::::::::::::::Fo:::::ooooo:::::orr::::::rrrrr::::::rtttttt:::::::tttttt i::::i s::::::ssss:::::s
F:::::::::::::::Fo::::o o::::o r:::::r r:::::r t:::::t i::::i s:::::s ssssss
F::::::FFFFFFFFFFo::::o o::::o r:::::r rrrrrrr t:::::t i::::i s::::::s
F:::::F o::::o o::::o r:::::r t:::::t i::::i s::::::s
F:::::F o::::o o::::o r:::::r t:::::t tttttt i::::i ssssss s:::::s
FF:::::::FF o:::::ooooo:::::o r:::::r t::::::tttt:::::ti::::::is:::::ssss::::::s
F::::::::FF o:::::::::::::::o r:::::r tt::::::::::::::ti::::::is::::::::::::::s
F::::::::FF oo:::::::::::oo r:::::r tt:::::::::::tti::::::i s:::::::::::ss
FFFFFFFFFFF ooooooooooo rrrrrrr ttttttttttt iiiiiiii sssssssssss
Discord: https://discord.gg/gDtTX62
An interactive, variable-dividend rate contract with an ICO-capped price floor and collectibles.
Bankroll contract, containing tokens purchased from all dividend-card profit and ICO dividends.
Acts as token repository for games on the Zethr platform.
**/
contract ZTHInterface {
function buyAndSetDivPercentage(address _referredBy, uint8 _divChoice, string providedUnhashedPass) public payable returns (uint);
function balanceOf(address who) public view returns (uint);
function transfer(address _to, uint _value) public returns (bool);
function transferFrom(address _from, address _toAddress, uint _amountOfTokens) public returns (bool);
function exit() public;
function sell(uint amountOfTokens) public;
function withdraw(address _recipient) public;
}
contract ERC223Receiving {
function tokenFallback(address _from, uint _amountOfTokens, bytes _data) public returns (bool);
}
contract ZethrBankroll is ERC223Receiving {
using SafeMath for uint;
/*=================================
= EVENTS =
=================================*/
event Confirmation(address indexed sender, uint indexed transactionId);
event Revocation(address indexed sender, uint indexed transactionId);
event Submission(uint indexed transactionId);
event Execution(uint indexed transactionId);
event ExecutionFailure(uint indexed transactionId);
event Deposit(address indexed sender, uint value);
event OwnerAddition(address indexed owner);
event OwnerRemoval(address indexed owner);
event WhiteListAddition(address indexed contractAddress);
event WhiteListRemoval(address indexed contractAddress);
event RequirementChange(uint required);
event DevWithdraw(uint amountTotal, uint amountPerPerson);
event EtherLogged(uint amountReceived, address sender);
event BankrollInvest(uint amountReceived);
event DailyTokenAdmin(address gameContract);
event DailyTokensSent(address gameContract, uint tokens);
event DailyTokensReceived(address gameContract, uint tokens);
/*=================================
= WITHDRAWAL CONSTANTS =
=================================*/
uint constant public MAX_OWNER_COUNT = 10;
uint constant public MAX_WITHDRAW_PCT_DAILY = 15;
uint constant public MAX_WITHDRAW_PCT_TX = 5;
uint constant internal resetTimer = 1 days;
/*=================================
= ZTH INTERFACE =
=================================*/
address internal zethrAddress;
ZTHInterface public ZTHTKN;
/*=================================
= VARIABLES =
=================================*/
mapping (uint => Transaction) public transactions;
mapping (uint => mapping (address => bool)) public confirmations;
mapping (address => bool) public isOwner;
mapping (address => bool) public isWhitelisted;
mapping (address => uint) public dailyTokensPerContract;
address internal divCardAddress;
address[] public owners;
address[] public whiteListedContracts;
uint public required;
uint public transactionCount;
uint internal dailyResetTime;
uint internal dailyTknLimit;
uint internal tknsDispensedToday;
bool internal reEntered = false;
/*=================================
= CUSTOM CONSTRUCTS =
=================================*/
struct Transaction {
address destination;
uint value;
bytes data;
bool executed;
}
struct TKN {
address sender;
uint value;
}
/*=================================
= MODIFIERS =
=================================*/
modifier onlyWallet() {
if (msg.sender != address(this))
revert();
_;
}
modifier contractIsNotWhiteListed(address contractAddress) {
if (isWhitelisted[contractAddress])
revert();
_;
}
modifier contractIsWhiteListed(address contractAddress) {
if (!isWhitelisted[contractAddress])
revert();
_;
}
modifier isAnOwner() {
address caller = msg.sender;
if (!isOwner[caller])
revert();
_;
}
modifier ownerDoesNotExist(address owner) {
if (isOwner[owner])
revert();
_;
}
modifier ownerExists(address owner) {
if (!isOwner[owner])
revert();
_;
}
modifier transactionExists(uint transactionId) {
if (transactions[transactionId].destination == 0)
revert();
_;
}
modifier confirmed(uint transactionId, address owner) {
if (!confirmations[transactionId][owner])
revert();
_;
}
modifier notConfirmed(uint transactionId, address owner) {
if (confirmations[transactionId][owner])
revert();
_;
}
modifier notExecuted(uint transactionId) {
if (transactions[transactionId].executed)
revert();
_;
}
modifier notNull(address _address) {
if (_address == 0)
revert();
_;
}
modifier validRequirement(uint ownerCount, uint _required) {
if ( ownerCount > MAX_OWNER_COUNT
|| _required > ownerCount
|| _required == 0
|| ownerCount == 0)
revert();
_;
}
/*=================================
= LIST OF OWNERS =
=================================*/
/*
This list is for reference/identification purposes only, and comprises the eight core Zethr developers.
For game contracts to be listed, they must be approved by a majority (i.e. currently five) of the owners.
Contracts can be delisted in an emergency by a single owner.
0x4F4eBF556CFDc21c3424F85ff6572C77c514Fcae // Norsefire
0x11e52c75998fe2E7928B191bfc5B25937Ca16741 // klob
0x20C945800de43394F70D789874a4daC9cFA57451 // Etherguy
0xef764BAC8a438E7E498c2E5fcCf0f174c3E3F8dB // blurr
0x8537aa2911b193e5B377938A723D805bb0865670 // oguzhanox
0x9D221b2100CbE5F05a0d2048E2556a6Df6f9a6C3 // Randall
0x71009e9E4e5e68e77ECc7ef2f2E95cbD98c6E696 // cryptodude
0xDa83156106c4dba7A26E9bF2Ca91E273350aa551 // TropicalRogue
*/
/*=================================
= PUBLIC FUNCTIONS =
=================================*/
/// @dev Contract constructor sets initial owners and required number of confirmations.
/// @param _owners List of initial owners.
/// @param _required Number of required confirmations.
constructor (address[] _owners, uint _required)
public
validRequirement(_owners.length, _required)
{
for (uint i=0; i<_owners.length; i++) {
if (isOwner[_owners[i]] || _owners[i] == 0)
revert();
isOwner[_owners[i]] = true;
}
owners = _owners;
required = _required;
dailyResetTime = now - (1 days);
}
/** Testing only.
function exitAll()
public
{
uint tokenBalance = ZTHTKN.balanceOf(address(this));
ZTHTKN.sell(tokenBalance - 1e18);
ZTHTKN.sell(1e18);
ZTHTKN.withdraw(address(0x0));
}
**/
function addZethrAddresses(address _zethr, address _divcards)
public
isAnOwner
{
zethrAddress = _zethr;
divCardAddress = _divcards;
ZTHTKN = ZTHInterface(zethrAddress);
}
/// @dev Fallback function allows Ether to be deposited.
function()
public
payable
{
}
uint NonICOBuyins;
function deposit()
public
payable
{
NonICOBuyins = NonICOBuyins.add(msg.value);
}
/// @dev Function to buy tokens with contract eth balance.
function buyTokens()
public
payable
isAnOwner
{
uint savings = address(this).balance;
if (savings > 0.01 ether) {
ZTHTKN.buyAndSetDivPercentage.value(savings)(address(0x0), 33, "");
emit BankrollInvest(savings);
}
else {
emit EtherLogged(msg.value, msg.sender);
}
}
function tokenFallback(address /*_from*/, uint /*_amountOfTokens*/, bytes /*_data*/) public returns (bool) {
// Nothing, for now. Just receives tokens.
}
/// @dev Calculates if an amount of tokens exceeds the aggregate daily limit of 15% of contract
/// balance or 5% of the contract balance on its own.
function permissibleTokenWithdrawal(uint _toWithdraw)
public
returns(bool)
{
uint currentTime = now;
uint tokenBalance = ZTHTKN.balanceOf(address(this));
uint maxPerTx = (tokenBalance.mul(MAX_WITHDRAW_PCT_TX)).div(100);
require (_toWithdraw <= maxPerTx);
if (currentTime - dailyResetTime >= resetTimer)
{
dailyResetTime = currentTime;
dailyTknLimit = (tokenBalance.mul(MAX_WITHDRAW_PCT_DAILY)).div(100);
tknsDispensedToday = _toWithdraw;
return true;
}
else
{
if (tknsDispensedToday.add(_toWithdraw) <= dailyTknLimit)
{
tknsDispensedToday += _toWithdraw;
return true;
}
else { return false; }
}
}
/// @dev Allows us to set the daily Token Limit
function setDailyTokenLimit(uint limit)
public
isAnOwner
{
dailyTknLimit = limit;
}
/// @dev Allows to add a new owner. Transaction has to be sent by wallet.
/// @param owner Address of new owner.
function addOwner(address owner)
public
onlyWallet
ownerDoesNotExist(owner)
notNull(owner)
validRequirement(owners.length + 1, required)
{
isOwner[owner] = true;
owners.push(owner);
emit OwnerAddition(owner);
}
/// @dev Allows to remove an owner. Transaction has to be sent by wallet.
/// @param owner Address of owner.
function removeOwner(address owner)
public
onlyWallet
ownerExists(owner)
validRequirement(owners.length, required)
{
isOwner[owner] = false;
for (uint i=0; i<owners.length - 1; i++)
if (owners[i] == owner) {
owners[i] = owners[owners.length - 1];
break;
}
owners.length -= 1;
if (required > owners.length)
changeRequirement(owners.length);
emit OwnerRemoval(owner);
}
/// @dev Allows to replace an owner with a new owner. Transaction has to be sent by wallet.
/// @param owner Address of owner to be replaced.
/// @param owner Address of new owner.
function replaceOwner(address owner, address newOwner)
public
onlyWallet
ownerExists(owner)
ownerDoesNotExist(newOwner)
{
for (uint i=0; i<owners.length; i++)
if (owners[i] == owner) {
owners[i] = newOwner;
break;
}
isOwner[owner] = false;
isOwner[newOwner] = true;
emit OwnerRemoval(owner);
emit OwnerAddition(newOwner);
}
/// @dev Allows to change the number of required confirmations. Transaction has to be sent by wallet.
/// @param _required Number of required confirmations.
function changeRequirement(uint _required)
public
onlyWallet
validRequirement(owners.length, _required)
{
required = _required;
emit RequirementChange(_required);
}
/// @dev Allows an owner to submit and confirm a transaction.
/// @param destination Transaction target address.
/// @param value Transaction ether value.
/// @param data Transaction data payload.
/// @return Returns transaction ID.
function submitTransaction(address destination, uint value, bytes data)
public
returns (uint transactionId)
{
transactionId = addTransaction(destination, value, data);
confirmTransaction(transactionId);
}
/// @dev Allows an owner to confirm a transaction.
/// @param transactionId Transaction ID.
function confirmTransaction(uint transactionId)
public
ownerExists(msg.sender)
transactionExists(transactionId)
notConfirmed(transactionId, msg.sender)
{
confirmations[transactionId][msg.sender] = true;
emit Confirmation(msg.sender, transactionId);
executeTransaction(transactionId);
}
/// @dev Allows an owner to revoke a confirmation for a transaction.
/// @param transactionId Transaction ID.
function revokeConfirmation(uint transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
confirmations[transactionId][msg.sender] = false;
emit Revocation(msg.sender, transactionId);
}
/// @dev Allows anyone to execute a confirmed transaction.
/// @param transactionId Transaction ID.
function executeTransaction(uint transactionId)
public
notExecuted(transactionId)
{
if (isConfirmed(transactionId)) {
Transaction storage txToExecute = transactions[transactionId];
txToExecute.executed = true;
if (txToExecute.destination.call.value(txToExecute.value)(txToExecute.data))
emit Execution(transactionId);
else {
emit ExecutionFailure(transactionId);
txToExecute.executed = false;
}
}
}
/// @dev Returns the confirmation status of a transaction.
/// @param transactionId Transaction ID.
/// @return Confirmation status.
function isConfirmed(uint transactionId)
public
constant
returns (bool)
{
uint count = 0;
for (uint i=0; i<owners.length; i++) {
if (confirmations[transactionId][owners[i]])
count += 1;
if (count == required)
return true;
}
}
/*=================================
= OPERATOR FUNCTIONS =
=================================*/
/// @dev Adds a new transaction to the transaction mapping, if transaction does not exist yet.
/// @param destination Transaction target address.
/// @param value Transaction ether value.
/// @param data Transaction data payload.
/// @return Returns transaction ID.
function addTransaction(address destination, uint value, bytes data)
internal
notNull(destination)
returns (uint transactionId)
{
transactionId = transactionCount;
transactions[transactionId] = Transaction({
destination: destination,
value: value,
data: data,
executed: false
});
transactionCount += 1;
emit Submission(transactionId);
}
/*
* Web3 call functions
*/
/// @dev Returns number of confirmations of a transaction.
/// @param transactionId Transaction ID.
/// @return Number of confirmations.
function getConfirmationCount(uint transactionId)
public
constant
returns (uint count)
{
for (uint i=0; i<owners.length; i++)
if (confirmations[transactionId][owners[i]])
count += 1;
}
/// @dev Returns total number of transactions after filers are applied.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return Total number of transactions after filters are applied.
function getTransactionCount(bool pending, bool executed)
public
constant
returns (uint count)
{
for (uint i=0; i<transactionCount; i++)
if ( pending && !transactions[i].executed
|| executed && transactions[i].executed)
count += 1;
}
/// @dev Returns list of owners.
/// @return List of owner addresses.
function getOwners()
public
constant
returns (address[])
{
return owners;
}
/// @dev Returns array with owner addresses, which confirmed transaction.
/// @param transactionId Transaction ID.
/// @return Returns array of owner addresses.
function getConfirmations(uint transactionId)
public
constant
returns (address[] _confirmations)
{
address[] memory confirmationsTemp = new address[](owners.length);
uint count = 0;
uint i;
for (i=0; i<owners.length; i++)
if (confirmations[transactionId][owners[i]]) {
confirmationsTemp[count] = owners[i];
count += 1;
}
_confirmations = new address[](count);
for (i=0; i<count; i++)
_confirmations[i] = confirmationsTemp[i];
}
/// @dev Returns list of transaction IDs in defined range.
/// @param from Index start position of transaction array.
/// @param to Index end position of transaction array.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return Returns array of transaction IDs.
function getTransactionIds(uint from, uint to, bool pending, bool executed)
public
constant
returns (uint[] _transactionIds)
{
uint[] memory transactionIdsTemp = new uint[](transactionCount);
uint count = 0;
uint i;
for (i=0; i<transactionCount; i++)
if ( pending && !transactions[i].executed
|| executed && transactions[i].executed)
{
transactionIdsTemp[count] = i;
count += 1;
}
_transactionIds = new uint[](to - from);
for (i=from; i<to; i++)
_transactionIds[i - from] = transactionIdsTemp[i];
}
// Additions for Bankroll
function whiteListContract(address contractAddress)
public
isAnOwner
contractIsNotWhiteListed(contractAddress)
notNull(contractAddress)
{
isWhitelisted[contractAddress] = true;
whiteListedContracts.push(contractAddress);
// We set the daily tokens for a particular contract in a separate call.
dailyTokensPerContract[contractAddress] = 0;
emit WhiteListAddition(contractAddress);
}
// Remove a whitelisted contract. This is an exception to the norm in that
// it can be invoked directly by any owner, in the event that a game is found
// to be bugged or otherwise faulty, so it can be shut down as an emergency measure.
// Iterates through the whitelisted contracts to find contractAddress,
// then swaps it with the last address in the list - then decrements length
function deWhiteListContract(address contractAddress)
public
isAnOwner
contractIsWhiteListed(contractAddress)
{
isWhitelisted[contractAddress] = false;
for (uint i=0; i < whiteListedContracts.length - 1; i++)
if (whiteListedContracts[i] == contractAddress) {
whiteListedContracts[i] = owners[whiteListedContracts.length - 1];
break;
}
whiteListedContracts.length -= 1;
emit WhiteListRemoval(contractAddress);
}
function contractTokenWithdraw(uint amount, address target) public
contractIsWhiteListed(msg.sender)
{
require(isWhitelisted[msg.sender]);
require(ZTHTKN.transfer(target, amount));
}
// Alters the amount of tokens allocated to a game contract on a daily basis.
function alterTokenGrant(address _contract, uint _newAmount)
public
isAnOwner
contractIsWhiteListed(_contract)
{
dailyTokensPerContract[_contract] = _newAmount;
}
function queryTokenGrant(address _contract)
public
view
returns (uint)
{
return dailyTokensPerContract[_contract];
}
// Function to be run by an owner (ideally on a cron job) which performs daily
// token collection and dispersal for all whitelisted contracts.
function dailyAccounting()
public
isAnOwner
{
for (uint i=0; i < whiteListedContracts.length; i++)
{
address _contract = whiteListedContracts[i];
if ( dailyTokensPerContract[_contract] > 0 )
{
allocateTokens(_contract);
emit DailyTokenAdmin(_contract);
}
}
}
// In the event that we want to manually take tokens back from a whitelisted contract,
// we can do so.
function retrieveTokens(address _contract, uint _amount)
public
isAnOwner
contractIsWhiteListed(_contract)
{
require(ZTHTKN.transferFrom(_contract, address(this), _amount));
}
// Dispenses daily amount of ZTH to whitelisted contract, or retrieves the excess.
// Block withdraws greater than MAX_WITHDRAW_PCT_TX of Zethr token balance.
// (May require occasional adjusting of the daily token allocation for contracts.)
function allocateTokens(address _contract)
public
isAnOwner
contractIsWhiteListed(_contract)
{
uint dailyAmount = dailyTokensPerContract[_contract];
uint zthPresent = ZTHTKN.balanceOf(_contract);
// Make sure that tokens aren't sent to a contract which is in the black.
if (zthPresent <= dailyAmount)
{
// We need to send tokens over, make sure it's a permitted amount, and then send.
uint toDispense = dailyAmount.sub(zthPresent);
// Make sure amount is <= tokenbalance*MAX_WITHDRAW_PCT_TX
require(permissibleTokenWithdrawal(toDispense));
require(ZTHTKN.transfer(_contract, toDispense));
emit DailyTokensSent(_contract, toDispense);
} else
{
// The contract in question has made a profit: retrieve the excess tokens.
uint toRetrieve = zthPresent.sub(dailyAmount);
require(ZTHTKN.transferFrom(_contract, address(this), toRetrieve));
emit DailyTokensReceived(_contract, toRetrieve);
}
emit DailyTokenAdmin(_contract);
}
// Dev withdrawal of tokens - splits equally among all owners of contract
function devTokenWithdraw(uint amount) public
onlyWallet
{
require(permissibleTokenWithdrawal(amount));
uint amountPerPerson = SafeMath.div(amount, owners.length);
for (uint i=0; i<owners.length; i++) {
ZTHTKN.transfer(owners[i], amountPerPerson);
}
emit DevWithdraw(amount, amountPerPerson);
}
// Change the dividend card address. Can't see why this would ever need
// to be invoked, but better safe than sorry.
function changeDivCardAddress(address _newDivCardAddress)
public
isAnOwner
{
divCardAddress = _newDivCardAddress;
}
// Receive Ether (from Zethr itself or any other source) and purchase tokens at the 33% dividend rate.
// If the amount is less than 0.01 Ether, the Ether is stored by the contract until the balance
// exceeds that limit and then purchases all it can.
function receiveDividends() public payable {
if (!reEntered) {
uint ActualBalance = (address(this).balance.sub(NonICOBuyins));
if (ActualBalance > 0.01 ether) {
reEntered = true;
ZTHTKN.buyAndSetDivPercentage.value(ActualBalance)(address(0x0), 33, "");
emit BankrollInvest(ActualBalance);
reEntered = false;
}
}
}
// Use all available balance to buy in
function buyInWithAllBalanced() public payable isAnOwner {
if (!reEntered) {
uint balance = address(this).balance;
require (balance > 0.01 ether);
ZTHTKN.buyAndSetDivPercentage.value(balance)(address(0x0), 33, "");
}
}
/*=================================
= UTILITIES =
=================================*/
// Convert an hexadecimal character to their value
function fromHexChar(uint c) public pure returns (uint) {
if (byte(c) >= byte('0') && byte(c) <= byte('9')) {
return c - uint(byte('0'));
}
if (byte(c) >= byte('a') && byte(c) <= byte('f')) {
return 10 + c - uint(byte('a'));
}
if (byte(c) >= byte('A') && byte(c) <= byte('F')) {
return 10 + c - uint(byte('A'));
}
}
// Convert an hexadecimal string to raw bytes
function fromHex(string s) public pure returns (bytes) {
bytes memory ss = bytes(s);
require(ss.length%2 == 0); // length must be even
bytes memory r = new bytes(ss.length/2);
for (uint i=0; i<ss.length/2; ++i) {
r[i] = byte(fromHexChar(uint(ss[2*i])) * 16 +
fromHexChar(uint(ss[2*i+1])));
}
return r;
}
}
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint a, uint b) internal pure returns (uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint a, uint b) internal pure returns (uint) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint a, uint b) internal pure returns (uint) {
assert(b <= a);
return a - b;
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
} | RE1 |
pragma solidity ^0.4.25;
contract c_BANK
{
function Put(uint _unlockTime)
public
payable
{
var acc = Acc[msg.sender];
acc.balance += msg.value;
acc.unlockTime = _unlockTime>now?_unlockTime:now;
LogFile.AddMessage(msg.sender,msg.value,"Put");
}
function Collect(uint _am)
public
payable
{
var acc = Acc[msg.sender];
if( acc.balance>=MinSum && acc.balance>=_am && now>acc.unlockTime)
{
if(msg.sender.call.value(_am)())
{
acc.balance-=_am;
LogFile.AddMessage(msg.sender,_am,"Collect");
}
}
}
function()
public
payable
{
Put(0);
}
struct Holder
{
uint unlockTime;
uint balance;
}
mapping (address => Holder) public Acc;
Log LogFile;
uint public MinSum = 2 ether;
function c_BANK(address log) public{
LogFile = Log(log);
}
}
contract Log
{
struct Message
{
address Sender;
string Data;
uint Val;
uint Time;
}
Message[] public History;
Message LastMsg;
function AddMessage(address _adr,uint _val,string _data)
public
{
LastMsg.Sender = _adr;
LastMsg.Time = now;
LastMsg.Val = _val;
LastMsg.Data = _data;
History.push(LastMsg);
}
} | RE1 |
End of preview. Expand
in Data Studio
Dataset Card for Balanced Ethereum Smart Contract
The rapid expansion of blockchain technology, particularly Ethereum, has driven widespread adoption of smart contracts. However, the security of these contracts remains a critical concern due to the increasing frequency and complexity of vulnerabilities. This paper presents a comprehensive approach to detecting vulnerabilities in Ethereum smart contracts using pre-trained Large Language Models (LLMs). We apply transformer-based LLMs, leveraging their ability to understand and analyze Solidity code to identify potential security flaws. Our methodology involves fine-tuning eight distinct pre-trained LLM models on curated datasets varying in types and distributions of vulnerabilities, including multi-class vulnerabilities. The datasets-SB Curate, Benmark Solidity Smart Contract, and ScrawID-were selected to ensure a thorough evaluation of model performance across different vulnerability types. We employed over-sampling techniques to address class imbalances, resulting in more reliable training outcomes. We extensively evaluate these models using precision, recall, accuracy, F1 score, and Receiver Operating Characteristics (ROC) curve metrics. Our results demonstrate that the transformer encoder architecture, with its multi-head attention and feed-forward mechanisms, effectively captures the nuances of smart contract vulnerabilities. The models show promising potential in enhancing the security and reliability of Ethereum smart contracts, offering a robust solution to challenges posed by software vulnerabilities in the blockchain ecosystem.
Data Collection and Processing
This dataset is processed from three public datasets and we used them for our proposed method in [1]. These datasets are: A benchmark dataset of Solidity smart contracts, SB Curate, and ScrawlD.
Citation [optional]
[1] T. -T. -H. Le, J. Kim, S. Lee and H. Kim, "Robust Vulnerability Detection in Solidity-Based Ethereum Smart Contracts Using Fine-Tuned Transformer Encoder Models," in IEEE Access, vol. 12, pp. 154700-154717, 2024, doi: 10.1109/ACCESS.2024.3482389. keywords: {Smart contracts;Codes;Transformers;Security;Solid modeling;Analytical models;Training;Encoding;Biological system modeling;Large language models;Ethereum smart contracts;large language models;multi-class imbalance;multi-class classification;smart contract vulnerability;solidity code},
BibTeX:
@ARTICLE{10720785, author={Le, Thi-Thu-Huong and Kim, Jaehyun and Lee, Sangmyeong and Kim, Howon}, journal={IEEE Access}, title={Robust Vulnerability Detection in Solidity-Based Ethereum Smart Contracts Using Fine-Tuned Transformer Encoder Models}, year={2024}, volume={12}, number={}, pages={154700-154717}, keywords={Smart contracts;Codes;Transformers;Security;Solid modeling;Analytical models;Training;Encoding;Biological system modeling;Large language models;Ethereum smart contracts;large language models;multi-class imbalance;multi-class classification;smart contract vulnerability;solidity code}, doi={10.1109/ACCESS.2024.3482389}}
@misc {le_2025, author = { {Le} }, title = { Balanced-Ethereum-Smart-Contract (Revision fba3170) }, year = 2025, url = { https://huggingface.co/datasets/Thi-Thu-Huong/Balanced-Ethereum-Smart-Contract }, doi = { 10.57967/hf/4850 }, publisher = { Hugging Face } }
Dataset Card Contact
Email: [email protected]
- Downloads last month
- 50