mirror of https://github.com/ConsenSys/mythril
Nikhil Parasaram
6 years ago
commit
7dc9b4b6d6
@ -0,0 +1,3 @@ |
|||||||
|
# This file is suitable for sourcing inside POSIX shell, e.g. bash as |
||||||
|
# well as for importing into Python |
||||||
|
VERSION="v0.18.9" # NOQA |
||||||
@ -0,0 +1,299 @@ |
|||||||
|
pragma solidity ^0.4.16; |
||||||
|
|
||||||
|
/** |
||||||
|
* @title SafeMath |
||||||
|
* @dev Math operations with safety checks that throw on error |
||||||
|
*/ |
||||||
|
library SafeMath { |
||||||
|
function mul(uint256 a, uint256 b) internal constant returns (uint256) { |
||||||
|
uint256 c = a * b; |
||||||
|
assert(a == 0 || c / a == b); |
||||||
|
return c; |
||||||
|
} |
||||||
|
|
||||||
|
function div(uint256 a, uint256 b) internal constant returns (uint256) { |
||||||
|
// assert(b > 0); // Solidity automatically throws when dividing by 0 |
||||||
|
uint256 c = a / b; |
||||||
|
// assert(a == b * c + a % b); // There is no case in which this doesn't hold |
||||||
|
return c; |
||||||
|
} |
||||||
|
|
||||||
|
function sub(uint256 a, uint256 b) internal constant returns (uint256) { |
||||||
|
assert(b <= a); |
||||||
|
return a - b; |
||||||
|
} |
||||||
|
|
||||||
|
function add(uint256 a, uint256 b) internal constant returns (uint256) { |
||||||
|
uint256 c = a + b; |
||||||
|
assert(c >= a); |
||||||
|
return c; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* @title ERC20Basic |
||||||
|
* @dev Simpler version of ERC20 interface |
||||||
|
* @dev see https://github.com/ethereum/EIPs/issues/179 |
||||||
|
*/ |
||||||
|
contract ERC20Basic { |
||||||
|
uint256 public totalSupply; |
||||||
|
function balanceOf(address who) public constant returns (uint256); |
||||||
|
function transfer(address to, uint256 value) public returns (bool); |
||||||
|
event Transfer(address indexed from, address indexed to, uint256 value); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* @title Basic token |
||||||
|
* @dev Basic version of StandardToken, with no allowances. |
||||||
|
*/ |
||||||
|
contract BasicToken is ERC20Basic { |
||||||
|
using SafeMath for uint256; |
||||||
|
|
||||||
|
mapping(address => uint256) balances; |
||||||
|
|
||||||
|
/** |
||||||
|
* @dev transfer token for a specified address |
||||||
|
* @param _to The address to transfer to. |
||||||
|
* @param _value The amount to be transferred. |
||||||
|
*/ |
||||||
|
function transfer(address _to, uint256 _value) public returns (bool) { |
||||||
|
require(_to != address(0)); |
||||||
|
require(_value > 0 && _value <= balances[msg.sender]); |
||||||
|
|
||||||
|
// SafeMath.sub will throw if there is not enough balance. |
||||||
|
balances[msg.sender] = balances[msg.sender].sub(_value); |
||||||
|
balances[_to] = balances[_to].add(_value); |
||||||
|
Transfer(msg.sender, _to, _value); |
||||||
|
return true; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* @dev Gets the balance of the specified address. |
||||||
|
* @param _owner The address to query the the balance of. |
||||||
|
* @return An uint256 representing the amount owned by the passed address. |
||||||
|
*/ |
||||||
|
function balanceOf(address _owner) public constant returns (uint256 balance) { |
||||||
|
return balances[_owner]; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* @title ERC20 interface |
||||||
|
* @dev see https://github.com/ethereum/EIPs/issues/20 |
||||||
|
*/ |
||||||
|
contract ERC20 is ERC20Basic { |
||||||
|
function allowance(address owner, address spender) public constant returns (uint256); |
||||||
|
function transferFrom(address from, address to, uint256 value) public returns (bool); |
||||||
|
function approve(address spender, uint256 value) public returns (bool); |
||||||
|
event Approval(address indexed owner, address indexed spender, uint256 value); |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
/** |
||||||
|
* @title Standard ERC20 token |
||||||
|
* |
||||||
|
* @dev Implementation of the basic standard token. |
||||||
|
* @dev https://github.com/ethereum/EIPs/issues/20 |
||||||
|
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol |
||||||
|
*/ |
||||||
|
contract StandardToken is ERC20, BasicToken { |
||||||
|
|
||||||
|
mapping (address => mapping (address => uint256)) internal allowed; |
||||||
|
|
||||||
|
|
||||||
|
/** |
||||||
|
* @dev Transfer tokens from one address to another |
||||||
|
* @param _from address The address which you want to send tokens from |
||||||
|
* @param _to address The address which you want to transfer to |
||||||
|
* @param _value uint256 the amount of tokens to be transferred |
||||||
|
*/ |
||||||
|
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { |
||||||
|
require(_to != address(0)); |
||||||
|
require(_value > 0 && _value <= balances[_from]); |
||||||
|
require(_value <= allowed[_from][msg.sender]); |
||||||
|
|
||||||
|
balances[_from] = balances[_from].sub(_value); |
||||||
|
balances[_to] = balances[_to].add(_value); |
||||||
|
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); |
||||||
|
Transfer(_from, _to, _value); |
||||||
|
return true; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender. |
||||||
|
* |
||||||
|
* Beware that changing an allowance with this method brings the risk that someone may use both the old |
||||||
|
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this |
||||||
|
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards: |
||||||
|
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 |
||||||
|
* @param _spender The address which will spend the funds. |
||||||
|
* @param _value The amount of tokens to be spent. |
||||||
|
*/ |
||||||
|
function approve(address _spender, uint256 _value) public returns (bool) { |
||||||
|
allowed[msg.sender][_spender] = _value; |
||||||
|
Approval(msg.sender, _spender, _value); |
||||||
|
return true; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* @dev Function to check the amount of tokens that an owner allowed to a spender. |
||||||
|
* @param _owner address The address which owns the funds. |
||||||
|
* @param _spender address The address which will spend the funds. |
||||||
|
* @return A uint256 specifying the amount of tokens still available for the spender. |
||||||
|
*/ |
||||||
|
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) { |
||||||
|
return allowed[_owner][_spender]; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* @title Ownable |
||||||
|
* @dev The Ownable contract has an owner address, and provides basic authorization control |
||||||
|
* functions, this simplifies the implementation of "user permissions". |
||||||
|
*/ |
||||||
|
contract Ownable { |
||||||
|
address public owner; |
||||||
|
|
||||||
|
|
||||||
|
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); |
||||||
|
|
||||||
|
|
||||||
|
/** |
||||||
|
* @dev The Ownable constructor sets the original `owner` of the contract to the sender |
||||||
|
* account. |
||||||
|
*/ |
||||||
|
function Ownable() { |
||||||
|
owner = msg.sender; |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
/** |
||||||
|
* @dev Throws if called by any account other than the owner. |
||||||
|
*/ |
||||||
|
modifier onlyOwner() { |
||||||
|
require(msg.sender == owner); |
||||||
|
_; |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
/** |
||||||
|
* @dev Allows the current owner to transfer control of the contract to a newOwner. |
||||||
|
* @param newOwner The address to transfer ownership to. |
||||||
|
*/ |
||||||
|
function transferOwnership(address newOwner) onlyOwner public { |
||||||
|
require(newOwner != address(0)); |
||||||
|
OwnershipTransferred(owner, newOwner); |
||||||
|
owner = newOwner; |
||||||
|
} |
||||||
|
|
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* @title Pausable |
||||||
|
* @dev Base contract which allows children to implement an emergency stop mechanism. |
||||||
|
*/ |
||||||
|
contract Pausable is Ownable { |
||||||
|
event Pause(); |
||||||
|
event Unpause(); |
||||||
|
|
||||||
|
bool public paused = false; |
||||||
|
|
||||||
|
|
||||||
|
/** |
||||||
|
* @dev Modifier to make a function callable only when the contract is not paused. |
||||||
|
*/ |
||||||
|
modifier whenNotPaused() { |
||||||
|
require(!paused); |
||||||
|
_; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* @dev Modifier to make a function callable only when the contract is paused. |
||||||
|
*/ |
||||||
|
modifier whenPaused() { |
||||||
|
require(paused); |
||||||
|
_; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* @dev called by the owner to pause, triggers stopped state |
||||||
|
*/ |
||||||
|
function pause() onlyOwner whenNotPaused public { |
||||||
|
paused = true; |
||||||
|
Pause(); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* @dev called by the owner to unpause, returns to normal state |
||||||
|
*/ |
||||||
|
function unpause() onlyOwner whenPaused public { |
||||||
|
paused = false; |
||||||
|
Unpause(); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* @title Pausable token |
||||||
|
* |
||||||
|
* @dev StandardToken modified with pausable transfers. |
||||||
|
**/ |
||||||
|
|
||||||
|
contract PausableToken is StandardToken, Pausable { |
||||||
|
|
||||||
|
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) { |
||||||
|
return super.transfer(_to, _value); |
||||||
|
} |
||||||
|
|
||||||
|
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) { |
||||||
|
return super.transferFrom(_from, _to, _value); |
||||||
|
} |
||||||
|
|
||||||
|
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) { |
||||||
|
return super.approve(_spender, _value); |
||||||
|
} |
||||||
|
|
||||||
|
function batchTransfer(address[] _receivers, uint256 _value) public whenNotPaused returns (bool) { |
||||||
|
uint cnt = _receivers.length; |
||||||
|
uint256 amount = uint256(cnt) * _value; |
||||||
|
require(cnt > 0 && cnt <= 20); |
||||||
|
require(_value > 0 && balances[msg.sender] >= amount); |
||||||
|
|
||||||
|
balances[msg.sender] = balances[msg.sender].sub(amount); |
||||||
|
for (uint i = 0; i < cnt; i++) { |
||||||
|
balances[_receivers[i]] = balances[_receivers[i]].add(_value); |
||||||
|
Transfer(msg.sender, _receivers[i], _value); |
||||||
|
} |
||||||
|
return true; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* @title Bec Token |
||||||
|
* |
||||||
|
* @dev Implementation of Bec Token based on the basic standard token. |
||||||
|
*/ |
||||||
|
contract BecToken is PausableToken { |
||||||
|
/** |
||||||
|
* Public variables of the token |
||||||
|
* The following variables are OPTIONAL vanities. One does not have to include them. |
||||||
|
* They allow one to customise the token contract & in no way influences the core functionality. |
||||||
|
* Some wallets/interfaces might not even bother to look at this information. |
||||||
|
*/ |
||||||
|
string public name = "BeautyChain"; |
||||||
|
string public symbol = "BEC"; |
||||||
|
string public version = '1.0.0'; |
||||||
|
uint8 public decimals = 18; |
||||||
|
|
||||||
|
/** |
||||||
|
* @dev Function to check the amount of tokens that an owner allowed to a spender. |
||||||
|
*/ |
||||||
|
function BecToken() { |
||||||
|
totalSupply = 7000000000 * (10**(uint256(decimals))); |
||||||
|
balances[msg.sender] = totalSupply; // Give the creator all initial tokens |
||||||
|
} |
||||||
|
|
||||||
|
function () { |
||||||
|
//if ether is sent to this address, send it back. |
||||||
|
revert(); |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,396 @@ |
|||||||
|
//sol Wallet |
||||||
|
// Multi-sig, daily-limited account proxy/wallet. |
||||||
|
// @authors: |
||||||
|
// Gav Wood <g@ethdev.com> |
||||||
|
// 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.9; |
||||||
|
|
||||||
|
contract WalletEvents { |
||||||
|
// 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); |
||||||
|
|
||||||
|
// 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); |
||||||
|
} |
||||||
|
|
||||||
|
contract WalletAbi { |
||||||
|
// Revokes a prior confirmation of the given operation |
||||||
|
function revoke(bytes32 _operation) external; |
||||||
|
|
||||||
|
// Replaces an owner `_from` with another `_to`. |
||||||
|
function changeOwner(address _from, address _to) external; |
||||||
|
|
||||||
|
function addOwner(address _owner) external; |
||||||
|
|
||||||
|
function removeOwner(address _owner) external; |
||||||
|
|
||||||
|
function changeRequirement(uint _newRequired) external; |
||||||
|
|
||||||
|
function isOwner(address _addr) constant returns (bool); |
||||||
|
|
||||||
|
function hasConfirmed(bytes32 _operation, address _owner) external constant returns (bool); |
||||||
|
|
||||||
|
// (re)sets the daily limit. needs many of the owners to confirm. doesn't alter the amount already spent today. |
||||||
|
function setDailyLimit(uint _newLimit) external; |
||||||
|
|
||||||
|
function execute(address _to, uint _value, bytes _data) external returns (bytes32 o_hash); |
||||||
|
function confirm(bytes32 _h) returns (bool o_success); |
||||||
|
} |
||||||
|
|
||||||
|
contract WalletLibrary is WalletEvents { |
||||||
|
// TYPES |
||||||
|
|
||||||
|
// struct for the status of a pending operation. |
||||||
|
struct PendingState { |
||||||
|
uint yetNeeded; |
||||||
|
uint ownersDone; |
||||||
|
uint index; |
||||||
|
} |
||||||
|
|
||||||
|
// Transaction structure to remember details of transaction lest it need be saved for a later call. |
||||||
|
struct Transaction { |
||||||
|
address to; |
||||||
|
uint value; |
||||||
|
bytes data; |
||||||
|
} |
||||||
|
|
||||||
|
// 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 |
||||||
|
|
||||||
|
// gets called when no other function matches |
||||||
|
function() payable { |
||||||
|
// just being sent some cash? |
||||||
|
if (msg.value > 0) |
||||||
|
Deposit(msg.sender, msg.value); |
||||||
|
} |
||||||
|
|
||||||
|
// constructor is given number of sigs required to do protected "onlymanyowners" transactions |
||||||
|
// as well as the selection of addresses capable of confirming them. |
||||||
|
function initMultiowned(address[] _owners, uint _required) only_uninitialized { |
||||||
|
m_numOwners = _owners.length + 1; |
||||||
|
m_owners[1] = uint(msg.sender); |
||||||
|
m_ownerIndex[uint(msg.sender)] = 1; |
||||||
|
for (uint i = 0; i < _owners.length; ++i) |
||||||
|
{ |
||||||
|
m_owners[2 + i] = uint(_owners[i]); |
||||||
|
m_ownerIndex[uint(_owners[i])] = 2 + 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 > 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) constant returns (bool) { |
||||||
|
return m_ownerIndex[uint(_addr)] > 0; |
||||||
|
} |
||||||
|
|
||||||
|
function hasConfirmed(bytes32 _operation, address _owner) external 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); |
||||||
|
} |
||||||
|
|
||||||
|
// constructor - stores initial daily limit and records the present day's index. |
||||||
|
function initDaylimit(uint _limit) only_uninitialized { |
||||||
|
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; |
||||||
|
} |
||||||
|
|
||||||
|
// throw unless the contract is not yet initialized. |
||||||
|
modifier only_uninitialized { if (m_numOwners > 0) throw; _; } |
||||||
|
|
||||||
|
// constructor - just pass on the owner array to the multiowned and |
||||||
|
// the limit to daylimit |
||||||
|
function initWallet(address[] _owners, uint _required, uint _daylimit) only_uninitialized { |
||||||
|
initDaylimit(_daylimit); |
||||||
|
initMultiowned(_owners, _required); |
||||||
|
} |
||||||
|
|
||||||
|
// kills the contract sending everything to `_to`. |
||||||
|
function kill(address _to) onlymanyowners(sha3(msg.data)) external { |
||||||
|
suicide(_to); |
||||||
|
} |
||||||
|
|
||||||
|
// 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 { |
||||||
|
if (!_to.call.value(_value)(_data)) |
||||||
|
throw; |
||||||
|
} |
||||||
|
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) { |
||||||
|
assembly { |
||||||
|
o_addr := create(_value, add(_code, 0x20), mload(_code)) |
||||||
|
jumpi(0xdeadbeef, iszero(extcodesize(o_addr))) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// 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 { |
||||||
|
if (!m_txs[_h].to.call.value(m_txs[_h].value)(m_txs[_h].data)) |
||||||
|
throw; |
||||||
|
} |
||||||
|
|
||||||
|
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 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; |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// 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; } |
||||||
|
|
||||||
|
function clearPending() internal { |
||||||
|
uint length = m_pendingIndex.length; |
||||||
|
|
||||||
|
for (uint i = 0; i < length; ++i) { |
||||||
|
delete m_txs[m_pendingIndex[i]]; |
||||||
|
|
||||||
|
if (m_pendingIndex[i] != 0) |
||||||
|
delete m_pending[m_pendingIndex[i]]; |
||||||
|
} |
||||||
|
|
||||||
|
delete m_pendingIndex; |
||||||
|
} |
||||||
|
|
||||||
|
// FIELDS |
||||||
|
address constant _walletLibrary = 0xcafecafecafecafecafecafecafecafecafecafe; |
||||||
|
|
||||||
|
// 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; |
||||||
|
|
||||||
|
uint public m_dailyLimit; |
||||||
|
uint public m_spentToday; |
||||||
|
uint public m_lastDay; |
||||||
|
|
||||||
|
// 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; |
||||||
|
|
||||||
|
// pending transactions we have at present. |
||||||
|
mapping (bytes32 => Transaction) m_txs; |
||||||
|
} |
||||||
@ -1,31 +0,0 @@ |
|||||||
contract Crowdfunding { |
|
||||||
|
|
||||||
mapping(address => uint) public balances; |
|
||||||
address public owner; |
|
||||||
uint256 INVEST_MIN = 1 ether; |
|
||||||
uint256 INVEST_MAX = 10 ether; |
|
||||||
|
|
||||||
modifier onlyOwner() { |
|
||||||
require(msg.sender == owner); |
|
||||||
_; |
|
||||||
} |
|
||||||
|
|
||||||
function crowdfunding() { |
|
||||||
owner = msg.sender; |
|
||||||
} |
|
||||||
|
|
||||||
function withdrawfunds() onlyOwner { |
|
||||||
msg.sender.transfer(this.balance); |
|
||||||
} |
|
||||||
|
|
||||||
function invest() public payable { |
|
||||||
require(msg.value > INVEST_MIN && msg.value < INVEST_MAX); |
|
||||||
|
|
||||||
balances[msg.sender] += msg.value; |
|
||||||
} |
|
||||||
|
|
||||||
function getBalance() public constant returns (uint) { |
|
||||||
return balances[msg.sender]; |
|
||||||
} |
|
||||||
|
|
||||||
} |
|
||||||
@ -0,0 +1,21 @@ |
|||||||
|
contract EtherStore { |
||||||
|
|
||||||
|
uint256 public withdrawalLimit = 1 ether; |
||||||
|
mapping(address => uint256) public lastWithdrawTime; |
||||||
|
mapping(address => uint256) public balances; |
||||||
|
|
||||||
|
function depositFunds() public payable { |
||||||
|
balances[msg.sender] += msg.value; |
||||||
|
} |
||||||
|
|
||||||
|
function withdrawFunds (uint256 _weiToWithdraw) public { |
||||||
|
require(balances[msg.sender] >= _weiToWithdraw); |
||||||
|
// limit the withdrawal |
||||||
|
require(_weiToWithdraw <= withdrawalLimit); |
||||||
|
// limit the time allowed to withdraw |
||||||
|
require(now >= lastWithdrawTime[msg.sender] + 1 weeks); |
||||||
|
require(msg.sender.call.value(_weiToWithdraw)()); |
||||||
|
balances[msg.sender] -= _weiToWithdraw; |
||||||
|
lastWithdrawTime[msg.sender] = now; |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,12 @@ |
|||||||
|
contract HashForEther { |
||||||
|
|
||||||
|
function withdrawWinnings() { |
||||||
|
// Winner if the last 8 hex characters of the address are 0. |
||||||
|
require(uint32(msg.sender) == 0); |
||||||
|
_sendWinnings(); |
||||||
|
} |
||||||
|
|
||||||
|
function _sendWinnings() { |
||||||
|
msg.sender.transfer(this.balance); |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,21 @@ |
|||||||
|
contract TimeLock { |
||||||
|
|
||||||
|
mapping(address => uint) public balances; |
||||||
|
mapping(address => uint) public lockTime; |
||||||
|
|
||||||
|
function deposit() public payable { |
||||||
|
balances[msg.sender] += msg.value; |
||||||
|
lockTime[msg.sender] = now + 1 weeks; |
||||||
|
} |
||||||
|
|
||||||
|
function increaseLockTime(uint _secondsToIncrease) public { |
||||||
|
lockTime[msg.sender] += _secondsToIncrease; |
||||||
|
} |
||||||
|
|
||||||
|
function withdraw() public { |
||||||
|
require(balances[msg.sender] > 0); |
||||||
|
require(now > lockTime[msg.sender]); |
||||||
|
balances[msg.sender] = 0; |
||||||
|
msg.sender.transfer(balances[msg.sender]); |
||||||
|
} |
||||||
|
} |
||||||
Loading…
Reference in new issue