Merge branch 'master' into feature/merkleproof

.coveralls.yml

-repo_token: AelGMv47LJ85e3KF1PhYBsjyduSjDmP0h

.gitignore

@@ -5,3 +5,5 @@ build/
 .DS_Store/
 /coverage
 coverage.json
+allFiredEvents
+scTopics

.solcover.js

+module.exports = {
+    norpc: true,
+    testCommand: 'node --max-old-space-size=4096 ../node_modules/.bin/truffle test --network coverage',
+    skipFiles: ['lifecycle/Migrations.sol']
+}

.travis.yml

 dist: trusty
-sudo: false
+sudo: required
 group: beta
 language: node_js
 node_js:
   - "6"
 cache:
   yarn: true
+env:
+  -
+  - SOLIDITY_COVERAGE=true
+matrix:
+  fast_finish: true
+  allow_failures:
+    - env: SOLIDITY_COVERAGE=true
 script:
-  - testrpc > /dev/null &
-  - truffle test
-after_script:
-  - yarn run coveralls
+  - yarn test

README.md

 # Zeppelin Solidity
 [![NPM Package](https://img.shields.io/npm/v/zeppelin-solidity.svg?style=flat-square)](https://www.npmjs.org/package/zeppelin-solidity)
 [![Build Status](https://img.shields.io/travis/OpenZeppelin/zeppelin-solidity.svg?branch=master&style=flat-square)](https://travis-ci.org/OpenZeppelin/zeppelin-solidity)
-[![Coverage Status](https://coveralls.io/repos/github/OpenZeppelin/zeppelin-solidity/badge.svg?branch=coveralls)](https://coveralls.io/github/OpenZeppelin/zeppelin-solidity?branch=coveralls)
+[![Coverage Status](https://coveralls.io/repos/github/OpenZeppelin/zeppelin-solidity/badge.svg?branch=master)](https://coveralls.io/github/OpenZeppelin/zeppelin-solidity?branch=master)
 
 OpenZeppelin is a library for writing secure [Smart Contracts](https://en.wikipedia.org/wiki/Smart_contract) on Ethereum.
 
@@ -16,7 +16,7 @@ With OpenZeppelin, you can build distributed applications, protocols and organiz
 OpenZeppelin integrates with [Truffle](https://github.com/ConsenSys/truffle), an Ethereum development environment. Please install Truffle and initialize your project with `truffle init`.
 
 ```sh
-npm install -g truffle@beta
+npm install -g truffle
 mkdir myproject && cd myproject
 truffle init
 ```

contracts/Bounty.sol

@@ -16,12 +16,10 @@ contract Bounty is PullPayment, Destructible {
   event TargetCreated(address createdAddress);
 
   /**
-   * @dev Fallback function allowing the contract to recieve funds, if they haven't already been claimed.
+   * @dev Fallback function allowing the contract to receive funds, if they haven't already been claimed.
    */
   function() payable {
-    if (claimed) {
-      throw;
-    }
+    require(!claimed);
   }
 
   /**
@@ -29,7 +27,7 @@ contract Bounty is PullPayment, Destructible {
    * msg.sender as a researcher
    * @return A target contract
    */
-  function createTarget() returns(Target) {
+  function createTarget() public returns(Target) {
     Target target = Target(deployContract());
     researchers[target] = msg.sender;
     TargetCreated(target);
@@ -46,15 +44,11 @@ contract Bounty is PullPayment, Destructible {
    * @dev Sends the contract funds to the researcher that proved the contract is broken.
    * @param target contract
    */
-  function claim(Target target) {
+  function claim(Target target) public {
     address researcher = researchers[target];
-    if (researcher == 0) {
-      throw;
-    }
+    require(researcher != 0);
     // Check Target contract invariants
-    if (target.checkInvariant()) {
-      throw;
-    }
+    require(!target.checkInvariant());
     asyncSend(researcher, this.balance);
     claimed = true;
   }
@@ -74,5 +68,5 @@ contract Target {
     * In order to win the bounty, security researchers will try to cause this broken state.
     * @return True if all invariant values are correct, false otherwise.
     */
-  function checkInvariant() returns(bool);
+  function checkInvariant() public returns(bool);
 }

contracts/DayLimit.sol

@@ -7,24 +7,24 @@ pragma solidity ^0.4.11;
  */
 contract DayLimit {
 
-  uint public dailyLimit;
-  uint public spentToday;
-  uint public lastDay;
+  uint256 public dailyLimit;
+  uint256 public spentToday;
+  uint256 public lastDay;
 
   /**
    * @dev Constructor that sets the passed value as a dailyLimit.
-   * @param _limit Uint to represent the daily limit.
+   * @param _limit uint256 to represent the daily limit.
    */
-  function DayLimit(uint _limit) {
+  function DayLimit(uint256 _limit) {
     dailyLimit = _limit;
     lastDay = today();
   }
 
   /**
    * @dev sets the daily limit. Does not alter the amount already spent today.
-   * @param _newLimit Uint to represent the new limit.
+   * @param _newLimit uint256 to represent the new limit.
    */
-  function _setDailyLimit(uint _newLimit) internal {
+  function _setDailyLimit(uint256 _newLimit) internal {
     dailyLimit = _newLimit;
   }
 
@@ -37,10 +37,10 @@ contract DayLimit {
 
   /**
    * @dev Checks to see if there is enough resource to spend today. If true, the resource may be expended.
-   * @param _value Uint representing the amount of resource to spend.
-   * @return A boolean that is True if the resource was spended and false otherwise.
+   * @param _value uint256 representing the amount of resource to spend.
+   * @return A boolean that is True if the resource was spent and false otherwise.
    */
-  function underLimit(uint _value) internal returns (bool) {
+  function underLimit(uint256 _value) internal returns (bool) {
     // reset the spend limit if we're on a different day to last time.
     if (today() > lastDay) {
       spentToday = 0;
@@ -57,19 +57,17 @@ contract DayLimit {
 
   /**
    * @dev Private function to determine today's index
-   * @return Uint of today's index.
+   * @return uint256 of today's index.
    */
-  function today() private constant returns (uint) {
+  function today() private constant returns (uint256) {
     return now / 1 days;
   }
 
   /**
    * @dev Simple modifier for daily limit.
    */
-  modifier limitedDaily(uint _value) {
-    if (!underLimit(_value)) {
-      throw;
-    }
+  modifier limitedDaily(uint256 _value) {
+    require(underLimit(_value));
     _;
   }
 }

contracts/ECRecovery.sol

+pragma solidity ^0.4.11;
+
+
+/**
+ * @title Eliptic curve signature operations
+ *
+ * @dev Based on https://gist.github.com/axic/5b33912c6f61ae6fd96d6c4a47afde6d
+ */
+
+library ECRecovery {
+
+  /**
+   * @dev Recover signer address from a message by using his signature
+   * @param hash bytes32 message, the hash is the signed message. What is recovered is the signer address.
+   * @param sig bytes signature, the signature is generated using web3.eth.sign()
+   */
+  function recover(bytes32 hash, bytes sig) public constant returns (address) {
+    bytes32 r;
+    bytes32 s;
+    uint8 v;
+
+    //Check the signature length
+    if (sig.length != 65) {
+      return (address(0));
+    }
+
+    // Divide the signature in r, s and v variables
+    assembly {
+      r := mload(add(sig, 32))
+      s := mload(add(sig, 64))
+      v := byte(0, mload(add(sig, 96)))
+    }
+
+    // Version of signature should be 27 or 28, but 0 and 1 are also possible versions
+    if (v < 27) {
+      v += 27;
+    }
+
+    // If the version is correct return the signer address
+    if (v != 27 && v != 28) {
+      return (address(0));
+    } else {
+      return ecrecover(hash, v, r, s);
+    }
+  }
+
+}

contracts/LimitBalance.sol

@@ -9,13 +9,13 @@ pragma solidity ^0.4.11;
  */
 contract LimitBalance {
 
-  uint public limit;
+  uint256 public limit;
 
   /**
    * @dev Constructor that sets the passed value as a limit.
-   * @param _limit Uint to represent the limit.
+   * @param _limit uint256 to represent the limit.
    */
-  function LimitBalance(uint _limit) {
+  function LimitBalance(uint256 _limit) {
     limit = _limit;
   }
 
@@ -23,9 +23,7 @@ contract LimitBalance {
    * @dev Checks if limit was reached. Case true, it throws.
    */
   modifier limitedPayable() {
-    if (this.balance > limit) {
-      throw;
-    }
+    require(this.balance <= limit);
     _;
 
   }

contracts/MultisigWallet.sol

-pragma solidity ^0.4.11;
-
-
-import "./ownership/Multisig.sol";
-import "./ownership/Shareable.sol";
-import "./DayLimit.sol";
-
-
-/**
- * MultisigWallet
- * Usage:
- *     bytes32 h = Wallet(w).from(oneOwner).execute(to, value, data);
- *     Wallet(w).from(anotherOwner).confirm(h);
- */
-contract MultisigWallet is Multisig, Shareable, DayLimit {
-
-  struct Transaction {
-    address to;
-    uint value;
-    bytes data;
-  }
-
-  /**
-   * Constructor, sets the owners addresses, number of approvals required, and daily spending limit
-   * @param _owners A list of owners.
-   * @param _required The amount required for a transaction to be approved.
-   */
-  function MultisigWallet(address[] _owners, uint _required, uint _daylimit)       
-    Shareable(_owners, _required)        
-    DayLimit(_daylimit) { }
-
-  /** 
-   * @dev destroys the contract sending everything to `_to`. 
-   */
-  function destroy(address _to) onlymanyowners(keccak256(msg.data)) external {
-    selfdestruct(_to);
-  }
-
-  /** 
-   * @dev Fallback function, receives value and emits a deposit event. 
-   */
-  function() payable {
-    // just being sent some cash?
-    if (msg.value > 0)
-      Deposit(msg.sender, msg.value);
-  }
-
-  /**
-   * @dev Outside-visible transaction entry point. Executes transaction immediately if below daily 
-   * spending 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.
-   * @param _to The receiver address
-   * @param _value The value to send
-   * @param _data The data part of the transaction
-   */
-  function execute(address _to, uint _value, bytes _data) external onlyOwner returns (bytes32 _r) {
-    // first, take the opportunity to check that we're under the daily limit.
-    if (underLimit(_value)) {
-      SingleTransact(msg.sender, _value, _to, _data);
-      // yes - just execute the call.
-      if (!_to.call.value(_value)(_data)) {
-        throw;
-      }
-      return 0;
-    }
-    // determine our operation hash.
-    _r = keccak256(msg.data, block.number);
-    if (!confirm(_r) && txs[_r].to == 0) {
-      txs[_r].to = _to;
-      txs[_r].value = _value;
-      txs[_r].data = _data;
-      ConfirmationNeeded(_r, msg.sender, _value, _to, _data);
-    }
-  }
-
-  /**
-   * @dev Confirm a transaction by providing just the hash. We use the previous transactions map, 
-   * txs, in order to determine the body of the transaction from the hash provided.
-   * @param _h The transaction hash to approve.
-   */
-  function confirm(bytes32 _h) onlymanyowners(_h) returns (bool) {
-    if (txs[_h].to != 0) {
-      if (!txs[_h].to.call.value(txs[_h].value)(txs[_h].data)) {
-        throw;
-      }
-      MultiTransact(msg.sender, _h, txs[_h].value, txs[_h].to, txs[_h].data);
-      delete txs[_h];
-      return true;
-    }
-  }
-
-  /** 
-   * @dev Updates the daily limit value. 
-   * @param _newLimit  Uint to represent the new limit.
-   */
-  function setDailyLimit(uint _newLimit) onlymanyowners(keccak256(msg.data)) external {
-    _setDailyLimit(_newLimit);
-  }
-
-  /** 
-   * @dev Resets the value spent to enable more spending
-   */
-  function resetSpentToday() onlymanyowners(keccak256(msg.data)) external {
-    _resetSpentToday();
-  }
-
-
-  // INTERNAL METHODS
-  /** 
-   * @dev Clears the list of transactions pending approval.
-   */
-  function clearPending() internal {
-    uint length = pendingsIndex.length;
-    for (uint i = 0; i < length; ++i) {
-      delete txs[pendingsIndex[i]];
-    }
-    super.clearPending();
-  }
-
-
-  // FIELDS
-
-  // pending transactions we have at present.
-  mapping (bytes32 => Transaction) txs;
-}

contracts/ReentrancyGuard.sol

@@ -22,13 +22,10 @@ contract ReentrancyGuard {
    * wrapper marked as `nonReentrant`.
    */
   modifier nonReentrant() {
-    if(rentrancy_lock == false) {
+    require(!rentrancy_lock);
     rentrancy_lock = true;
     _;
     rentrancy_lock = false;
-    } else {
-      throw;
-    }
   }
 
 }

contracts/crowdsale/CappedCrowdsale.sol

+pragma solidity ^0.4.11;
+
+import '../math/SafeMath.sol';
+import './Crowdsale.sol';
+
+/**
+ * @title CappedCrowdsale
+ * @dev Extension of Crowdsale with a max amount of funds raised
+ */
+contract CappedCrowdsale is Crowdsale {
+  using SafeMath for uint256;
+
+  uint256 public cap;
+
+  function CappedCrowdsale(uint256 _cap) {
+    require(_cap > 0);
+    cap = _cap;
+  }
+
+  // overriding Crowdsale#validPurchase to add extra cap logic
+  // @return true if investors can buy at the moment
+  function validPurchase() internal constant returns (bool) {
+    bool withinCap = weiRaised.add(msg.value) <= cap;
+    return super.validPurchase() && withinCap;
+  }
+
+  // overriding Crowdsale#hasEnded to add cap logic
+  // @return true if crowdsale event has ended
+  function hasEnded() public constant returns (bool) {
+    bool capReached = weiRaised >= cap;
+    return super.hasEnded() || capReached;
+  }
+
+}

contracts/crowdsale/Crowdsale.sol

+pragma solidity ^0.4.11;
+
+import '../token/MintableToken.sol';
+import '../math/SafeMath.sol';
+
+/**
+ * @title Crowdsale
+ * @dev Crowdsale is a base contract for managing a token crowdsale.
+ * Crowdsales have a start and end timestamps, where investors can make
+ * token purchases and the crowdsale will assign them tokens based
+ * on a token per ETH rate. Funds collected are forwarded to a wallet
+ * as they arrive.
+ */
+contract Crowdsale {
+  using SafeMath for uint256;
+
+  // The token being sold
+  MintableToken public token;
+
+  // start and end timestamps where investments are allowed (both inclusive)
+  uint256 public startTime;
+  uint256 public endTime;
+
+  // address where funds are collected
+  address public wallet;
+
+  // how many token units a buyer gets per wei
+  uint256 public rate;
+
+  // amount of raised money in wei
+  uint256 public weiRaised;
+
+  /**
+   * event for token purchase logging
+   * @param purchaser who paid for the tokens
+   * @param beneficiary who got the tokens
+   * @param value weis paid for purchase
+   * @param amount amount of tokens purchased
+   */
+  event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
+
+
+  function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) {
+    require(_startTime >= now);
+    require(_endTime >= _startTime);
+    require(_rate > 0);
+    require(_wallet != 0x0);
+
+    token = createTokenContract();
+    startTime = _startTime;
+    endTime = _endTime;
+    rate = _rate;
+    wallet = _wallet;
+  }
+
+  // creates the token to be sold.
+  // override this method to have crowdsale of a specific mintable token.
+  function createTokenContract() internal returns (MintableToken) {
+    return new MintableToken();
+  }
+
+
+  // fallback function can be used to buy tokens
+  function () payable {
+    buyTokens(msg.sender);
+  }
+
+  // low level token purchase function
+  function buyTokens(address beneficiary) public payable {
+    require(beneficiary != 0x0);
+    require(validPurchase());
+
+    uint256 weiAmount = msg.value;
+
+    // calculate token amount to be created
+    uint256 tokens = weiAmount.mul(rate);
+
+    // update state
+    weiRaised = weiRaised.add(weiAmount);
+
+    token.mint(beneficiary, tokens);
+    TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
+
+    forwardFunds();
+  }
+
+  // send ether to the fund collection wallet
+  // override to create custom fund forwarding mechanisms
+  function forwardFunds() internal {
+    wallet.transfer(msg.value);
+  }
+
+  // @return true if the transaction can buy tokens
+  function validPurchase() internal constant returns (bool) {
+    bool withinPeriod = now >= startTime && now <= endTime;
+    bool nonZeroPurchase = msg.value != 0;
+    return withinPeriod && nonZeroPurchase;
+  }
+
+  // @return true if crowdsale event has ended
+  function hasEnded() public constant returns (bool) {
+    return now > endTime;
+  }
+
+
+}

contracts/crowdsale/FinalizableCrowdsale.sol

+pragma solidity ^0.4.11;
+
+import '../math/SafeMath.sol';
+import '../ownership/Ownable.sol';
+import './Crowdsale.sol';
+
+/**
+ * @title FinalizableCrowdsale
+ * @dev Extension of Crowdsale where an owner can do extra work
+ * after finishing.
+ */
+contract FinalizableCrowdsale is Crowdsale, Ownable {
+  using SafeMath for uint256;
+
+  bool public isFinalized = false;
+
+  event Finalized();
+
+  /**
+   * @dev Must be called after crowdsale ends, to do some extra finalization
+   * work. Calls the contract's finalization function.
+   */
+  function finalize() onlyOwner public {
+    require(!isFinalized);
+    require(hasEnded());
+
+    finalization();
+    Finalized();
+
+    isFinalized = true;
+  }
+
+  /**
+   * @dev Can be overridden to add finalization logic. The overriding function
+   * should call super.finalization() to ensure the chain of finalization is
+   * executed entirely.
+   */
+  function finalization() internal {
+  }
+}

contracts/crowdsale/RefundVault.sol

+pragma solidity ^0.4.11;
+
+import '../math/SafeMath.sol';
+import '../ownership/Ownable.sol';
+
+/**
+ * @title RefundVault
+ * @dev This contract is used for storing funds while a crowdsale
+ * is in progress. Supports refunding the money if crowdsale fails,
+ * and forwarding it if crowdsale is successful.
+ */
+contract RefundVault is Ownable {
+  using SafeMath for uint256;
+
+  enum State { Active, Refunding, Closed }
+
+  mapping (address => uint256) public deposited;
+  address public wallet;
+  State public state;
+
+  event Closed();
+  event RefundsEnabled();
+  event Refunded(address indexed beneficiary, uint256 weiAmount);
+
+  function RefundVault(address _wallet) {
+    require(_wallet != 0x0);
+    wallet = _wallet;
+    state = State.Active;
+  }
+
+  function deposit(address investor) onlyOwner public payable {
+    require(state == State.Active);
+    deposited[investor] = deposited[investor].add(msg.value);
+  }
+
+  function close() onlyOwner public {
+    require(state == State.Active);
+    state = State.Closed;
+    Closed();
+    wallet.transfer(this.balance);
+  }
+
+  function enableRefunds() onlyOwner public {
+    require(state == State.Active);
+    state = State.Refunding;
+    RefundsEnabled();
+  }
+
+  function refund(address investor) public {
+    require(state == State.Refunding);
+    uint256 depositedValue = deposited[investor];
+    deposited[investor] = 0;
+    investor.transfer(depositedValue);
+    Refunded(investor, depositedValue);
+  }
+}

contracts/crowdsale/RefundableCrowdsale.sol

+pragma solidity ^0.4.11;
+
+
+import '../math/SafeMath.sol';
+import './FinalizableCrowdsale.sol';
+import './RefundVault.sol';
+
+
+/**
+ * @title RefundableCrowdsale
+ * @dev Extension of Crowdsale contract that adds a funding goal, and
+ * the possibility of users getting a refund if goal is not met.
+ * Uses a RefundVault as the crowdsale's vault.
+ */
+contract RefundableCrowdsale is FinalizableCrowdsale {
+  using SafeMath for uint256;
+
+  // minimum amount of funds to be raised in weis
+  uint256 public goal;
+
+  // refund vault used to hold funds while crowdsale is running
+  RefundVault public vault;
+
+  function RefundableCrowdsale(uint256 _goal) {
+    require(_goal > 0);
+    vault = new RefundVault(wallet);
+    goal = _goal;
+  }
+
+  // We're overriding the fund forwarding from Crowdsale.
+  // In addition to sending the funds, we want to call
+  // the RefundVault deposit function
+  function forwardFunds() internal {
+    vault.deposit.value(msg.value)(msg.sender);
+  }
+
+  // if crowdsale is unsuccessful, investors can claim refunds here
+  function claimRefund() public {
+    require(isFinalized);
+    require(!goalReached());
+
+    vault.refund(msg.sender);
+  }
+
+  // vault finalization task, called when owner calls finalize()
+  function finalization() internal {
+    if (goalReached()) {
+      vault.close();
+    } else {
+      vault.enableRefunds();
+    }
+
+    super.finalization();
+  }
+
+  function goalReached() public constant returns (bool) {
+    return weiRaised >= goal;
+  }
+
+}

contracts/examples/SampleCrowdsale.sol

+pragma solidity ^0.4.11;
+
+import "../crowdsale/CappedCrowdsale.sol";
+import "../crowdsale/RefundableCrowdsale.sol";
+import "../token/MintableToken.sol";
+
+/**
+ * @title SampleCrowdsaleToken
+ * @dev Very simple ERC20 Token that can be minted.
+ * It is meant to be used in a crowdsale contract.
+ */
+contract SampleCrowdsaleToken is MintableToken {
+
+  string public constant name = "Sample Crowdsale Token";
+  string public constant symbol = "SCT";
+  uint8 public constant decimals = 18;
+
+}
+
+/**
+ * @title SampleCrowdsale
+ * @dev This is an example of a fully fledged crowdsale.
+ * The way to add new features to a base crowdsale is by multiple inheritance.
+ * In this example we are providing following extensions:
+ * CappedCrowdsale - sets a max boundary for raised funds
+ * RefundableCrowdsale - set a min goal to be reached and returns funds if it's not met
+ *
+ * After adding multiple features it's good practice to run integration tests
+ * to ensure that subcontracts works together as intended.
+ */
+contract SampleCrowdsale is CappedCrowdsale, RefundableCrowdsale {
+
+  function SampleCrowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, uint256 _goal, uint256 _cap, address _wallet)
+    CappedCrowdsale(_cap)
+    FinalizableCrowdsale()
+    RefundableCrowdsale(_goal)
+    Crowdsale(_startTime, _endTime, _rate, _wallet)
+  {
+    //As goal needs to be met for a successful crowdsale
+    //the value needs to less or equal than a cap which is limit for accepted funds
+    require(_goal <= _cap);
+  }
+
+  function createTokenContract() internal returns (MintableToken) {
+    return new SampleCrowdsaleToken();
+  }
+
+}

contracts/token/SimpleToken.sol → contracts/examples/SimpleToken.sol

 pragma solidity ^0.4.11;
 
 
-import "./StandardToken.sol";
+import "../token/StandardToken.sol";
 
 
 /**
@@ -12,13 +12,14 @@ import "./StandardToken.sol";
  */
 contract SimpleToken is StandardToken {
 
-  string public name = "SimpleToken";
-  string public symbol = "SIM";
-  uint public decimals = 18;
-  uint public INITIAL_SUPPLY = 10000;
+  string public constant name = "SimpleToken";
+  string public constant symbol = "SIM";
+  uint8 public constant decimals = 18;
+
+  uint256 public constant INITIAL_SUPPLY = 10000 * (10 ** uint256(decimals));
 
   /**
-   * @dev Contructor that gives msg.sender all of existing tokens. 
+   * @dev Constructor that gives msg.sender all of existing tokens.
    */
   function SimpleToken() {
     totalSupply = INITIAL_SUPPLY;

contracts/lifecycle/Destructible.sol

@@ -15,11 +15,11 @@ contract Destructible is Ownable {
   /**
    * @dev Transfers the current balance to the owner and terminates the contract.
    */
-  function destroy() onlyOwner {
+  function destroy() onlyOwner public {
     selfdestruct(owner);
   }
 
-  function destroyAndSend(address _recipient) onlyOwner {
+  function destroyAndSend(address _recipient) onlyOwner public {
     selfdestruct(_recipient);
   }
 }

contracts/lifecycle/Migrations.sol

@@ -8,13 +8,13 @@ import '../ownership/Ownable.sol';
  * @dev This is a truffle contract, needed for truffle integration, not meant for use by Zeppelin users.
  */
 contract Migrations is Ownable {
-  uint public lastCompletedMigration;
+  uint256 public lastCompletedMigration;
 
-  function setCompleted(uint completed) onlyOwner {
+  function setCompleted(uint256 completed) onlyOwner public {
     lastCompletedMigration = completed;
   }
 
-  function upgrade(address newAddress) onlyOwner {
+  function upgrade(address newAddress) onlyOwner public {
     Migrations upgraded = Migrations(newAddress);
     upgraded.setCompleted(lastCompletedMigration);
   }

contracts/lifecycle/Pausable.sol

@@ -16,36 +16,34 @@ contract Pausable is Ownable {
 
 
   /**
-   * @dev modifier to allow actions only when the contract IS paused
+   * @dev Modifier to make a function callable only when the contract is not paused.
    */
   modifier whenNotPaused() {
-    if (paused) throw;
+    require(!paused);
     _;
   }
 
   /**
-   * @dev modifier to allow actions only when the contract IS NOT paused
+   * @dev Modifier to make a function callable only when the contract is paused.
    */
-  modifier whenPaused {
-    if (!paused) throw;
+  modifier whenPaused() {
+    require(paused);
     _;
   }
 
   /**
    * @dev called by the owner to pause, triggers stopped state
    */
-  function pause() onlyOwner whenNotPaused returns (bool) {
+  function pause() onlyOwner whenNotPaused public {
     paused = true;
     Pause();
-    return true;
   }
 
   /**
    * @dev called by the owner to unpause, returns to normal state
    */
-  function unpause() onlyOwner whenPaused returns (bool) {
+  function unpause() onlyOwner whenPaused public {
     paused = false;
     Unpause();
-    return true;
   }
 }

contracts/lifecycle/TokenDestructible.sol

@@ -21,10 +21,10 @@ contract TokenDestructible is Ownable {
    * @notice The called token contracts could try to re-enter this contract. Only
    supply token contracts you trust.
    */
-  function destroy(address[] tokens) onlyOwner {
+  function destroy(address[] tokens) onlyOwner public {
 
     // Transfer tokens to owner
-    for(uint i = 0; i < tokens.length; i++) {
+    for(uint256 i = 0; i < tokens.length; i++) {
       ERC20Basic token = ERC20Basic(tokens[i]);
       uint256 balance = token.balanceOf(this);
       token.transfer(owner, balance);

contracts/SafeMath.sol → contracts/math/Math.sol

 pragma solidity ^0.4.11;
 
-
 /**
- * Math operations with safety checks
+ * @title Math
+ * @dev Assorted math operations
  */
-library SafeMath {
-  function mul(uint a, uint b) internal returns (uint) {
-    uint c = a * b;
-    assert(a == 0 || c / a == b);
-    return c;
-  }
-
-  function div(uint a, uint b) internal returns (uint) {
-    // assert(b > 0); // 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;
-  }
-
-  function sub(uint a, uint b) internal returns (uint) {
-    assert(b <= a);
-    return a - b;
-  }
-
-  function add(uint a, uint b) internal returns (uint) {
-    uint c = a + b;
-    assert(c >= a);
-    return c;
-  }
 
+library Math {
   function max64(uint64 a, uint64 b) internal constant returns (uint64) {
     return a >= b ? a : b;
   }
@@ -44,10 +21,4 @@ library SafeMath {
   function min256(uint256 a, uint256 b) internal constant returns (uint256) {
     return a < b ? a : b;
   }
-
-  function assert(bool assertion) internal {
-    if (!assertion) {
-      throw;
-    }
-  }
 }

contracts/math/SafeMath.sol

+pragma solidity ^0.4.11;
+
+
+/**
+ * @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;
+  }
+}

contracts/ownership/CanReclaimToken.sol

+pragma solidity ^0.4.11;
+
+import "./Ownable.sol";
+import "../token/ERC20Basic.sol";
+import "../token/SafeERC20.sol";
+
+/**
+ * @title Contracts that should be able to recover tokens
+ * @author SylTi
+ * @dev This allow a contract to recover any ERC20 token received in a contract by transferring the balance to the contract owner.
+ * This will prevent any accidental loss of tokens.
+ */
+contract CanReclaimToken is Ownable {
+  using SafeERC20 for ERC20Basic;
+
+  /**
+   * @dev Reclaim all ERC20Basic compatible tokens
+   * @param token ERC20Basic The address of the token contract
+   */
+  function reclaimToken(ERC20Basic token) external onlyOwner {
+    uint256 balance = token.balanceOf(this);
+    token.safeTransfer(owner, balance);
+  }
+
+}

contracts/ownership/Claimable.sol

@@ -16,9 +16,7 @@ contract Claimable is Ownable {
    * @dev Modifier throws if called by any account other than the pendingOwner.
    */
   modifier onlyPendingOwner() {
-    if (msg.sender != pendingOwner) {
-      throw;
-    }
+    require(msg.sender == pendingOwner);
     _;
   }
 
@@ -26,14 +24,15 @@ contract Claimable is Ownable {
    * @dev Allows the current owner to set the pendingOwner address.
    * @param newOwner The address to transfer ownership to.
    */
-  function transferOwnership(address newOwner) onlyOwner {
+  function transferOwnership(address newOwner) onlyOwner public {
     pendingOwner = newOwner;
   }
 
   /**
    * @dev Allows the pendingOwner address to finalize the transfer.
    */
-  function claimOwnership() onlyPendingOwner {
+  function claimOwnership() onlyPendingOwner public {
+    OwnershipTransferred(owner, pendingOwner);
     owner = pendingOwner;
     pendingOwner = 0x0;
   }

contracts/ownership/Contactable.sol

@@ -15,7 +15,7 @@ contract Contactable is Ownable{
      * @dev Allows the owner to set a string with their contact information.
      * @param info The contact information to attach to the contract.
      */
-    function setContactInformation(string info) onlyOwner{
+    function setContactInformation(string info) onlyOwner public {
          contactInformation = info;
      }
 }

contracts/ownership/DelayedClaimable.sol

@@ -11,8 +11,8 @@ import './Claimable.sol';
  */
 contract DelayedClaimable is Claimable {
 
-  uint public end;
-  uint public start;
+  uint256 public end;
+  uint256 public start;
 
   /**
    * @dev Used to specify the time period during which a pending
@@ -20,9 +20,8 @@ contract DelayedClaimable is Claimable {
    * @param _start The earliest time ownership can be claimed.
    * @param _end The latest time ownership can be claimed.
    */
-  function setLimits(uint _start, uint _end) onlyOwner {
-    if (_start > _end)
-        throw;
+  function setLimits(uint256 _start, uint256 _end) onlyOwner public {
+    require(_start <= _end);
     end = _end;
     start = _start;
   }
@@ -32,9 +31,9 @@ contract DelayedClaimable is Claimable {
    * @dev Allows the pendingOwner address to finalize the transfer, as long as it is called within
    * the specified start and end time.
    */
-  function claimOwnership() onlyPendingOwner {
-    if ((block.number > end) || (block.number < start))
-        throw;
+  function claimOwnership() onlyPendingOwner public {
+    require((block.number <= end) && (block.number >= start));
+    OwnershipTransferred(owner, pendingOwner);
     owner = pendingOwner;
     pendingOwner = 0x0;
     end = 0;

contracts/ownership/HasNoEther.sol

@@ -22,9 +22,7 @@ contract HasNoEther is Ownable {
   * we could use assembly to access msg.value.
   */
   function HasNoEther() payable {
-    if(msg.value > 0) {
-      throw;
-    }
+    require(msg.value == 0);
   }
 
   /**
@@ -37,8 +35,6 @@ contract HasNoEther is Ownable {
    * @dev Transfer all Ether held by the contract to the owner.
    */
   function reclaimEther() external onlyOwner {
-    if(!owner.send(this.balance)) {
-      throw;
-    }
+    assert(owner.send(this.balance));
   }
 }

contracts/ownership/HasNoTokens.sol

 pragma solidity ^0.4.11;
 
-import "./Ownable.sol";
-import "../token/ERC20Basic.sol";
+import "./CanReclaimToken.sol";
 
 /**
  * @title Contracts that should not own Tokens
@@ -10,25 +9,16 @@ import "../token/ERC20Basic.sol";
  * Should tokens (any ERC20Basic compatible) end up in the contract, it allows the
  * owner to reclaim the tokens.
  */
-contract HasNoTokens is Ownable {
+contract HasNoTokens is CanReclaimToken {
 
  /**
   * @dev Reject all ERC23 compatible tokens
   * @param from_ address The address that is transferring the tokens
-  * @param value_ Uint the amount of the specified token
+  * @param value_ uint256 the amount of the specified token
   * @param data_ Bytes The data passed from the caller.
   */
-  function tokenFallback(address from_, uint value_, bytes data_) external {
-    throw;
+  function tokenFallback(address from_, uint256 value_, bytes data_) external {
+    revert();
   }
 
-  /**
-   * @dev Reclaim all ERC20Basic compatible tokens
-   * @param tokenAddr address The address of the token contract
-   */
-  function reclaimToken(address tokenAddr) external onlyOwner {
-    ERC20Basic tokenInst = ERC20Basic(tokenAddr);
-    uint256 balance = tokenInst.balanceOf(this);
-    tokenInst.transfer(owner, balance);
-  }
 }

contracts/ownership/Multisig.sol

-pragma solidity ^0.4.11;
-
-
-/**
- * @title Multisig
- * @dev 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);
-  // 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);
-  // 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);
-  function confirm(bytes32 _h) returns (bool);
-}

contracts/ownership/Ownable.sol

@@ -10,6 +10,9 @@ 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.
@@ -23,9 +26,7 @@ contract Ownable {
    * @dev Throws if called by any account other than the owner.
    */
   modifier onlyOwner() {
-    if (msg.sender != owner) {
-      throw;
-    }
+    require(msg.sender == owner);
     _;
   }
 
@@ -34,10 +35,10 @@ contract Ownable {
    * @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 {
-    if (newOwner != address(0)) {
+  function transferOwnership(address newOwner) onlyOwner public {
+    require(newOwner != address(0));
+    OwnershipTransferred(owner, newOwner);
     owner = newOwner;
   }
-  }
 
 }

contracts/ownership/Shareable.sol

-pragma solidity ^0.4.11;
-
-
-/**
- * @title Shareable
- * @dev 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.
- * @dev 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) before the interior is executed.
- */
-contract Shareable {
-
-  // struct for the status of a pending operation.
-  struct PendingState {
-    uint yetNeeded;
-    uint ownersDone;
-    uint index;
-  }
-
-  // the number of owners that must confirm the same operation before it is run.
-  uint public required;
-
-  // list of owners
-  address[256] owners;
-  // index on the list of owners to allow reverse lookup
-  mapping(address => uint) ownerIndex;
-  // the ongoing operations.
-  mapping(bytes32 => PendingState) pendings;
-  bytes32[] pendingsIndex;
-
-
-  // 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);
-
-
-  // simple single-sig function modifier.
-  modifier onlyOwner {
-    if (!isOwner(msg.sender)) {
-      throw;
-    }
-    _;
-  }
-  
-  /** 
-   * @dev Modifier for multisig functions. 
-   * @param _operation 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)) {
-      _;
-    }
-  }
-
-  /** 
-   * @dev Constructor is given the number of sigs required to do protected "onlymanyowners" 
-   * transactions as well as the selection of addresses capable of confirming them.
-   * @param _owners A list of owners.
-   * @param _required The amount required for a transaction to be approved.
-   */
-  function Shareable(address[] _owners, uint _required) {
-    owners[1] = msg.sender;
-    ownerIndex[msg.sender] = 1;
-    for (uint i = 0; i < _owners.length; ++i) {
-      owners[2 + i] = _owners[i];
-      ownerIndex[_owners[i]] = 2 + i;
-    }
-    required = _required;
-    if (required > owners.length) {
-      throw;
-    }
-  }
-
-  /**
-   * @dev Revokes a prior confirmation of the given operation.
-   * @param _operation A string identifying the operation.
-   */
-  function revoke(bytes32 _operation) external {
-    uint index = ownerIndex[msg.sender];
-    // make sure they're an owner
-    if (index == 0) {
-      return;
-    }
-    uint ownerIndexBit = 2**index;
-    var pending = pendings[_operation];
-    if (pending.ownersDone & ownerIndexBit > 0) {
-      pending.yetNeeded++;
-      pending.ownersDone -= ownerIndexBit;
-      Revoke(msg.sender, _operation);
-    }
-  }
-
-  /**
-   * @dev Gets an owner by 0-indexed position (using numOwners as the count)
-   * @param ownerIndex Uint The index of the owner
-   * @return The address of the owner
-   */
-  function getOwner(uint ownerIndex) external constant returns (address) {
-    return address(owners[ownerIndex + 1]);
-  }
-
-  /**
-   * @dev Checks if given address is an owner.
-   * @param _addr address The address which you want to check.
-   * @return True if the address is an owner and fase otherwise.
-   */
-  function isOwner(address _addr) constant returns (bool) {
-    return ownerIndex[_addr] > 0;
-  }
-
-  /**
-   * @dev Function to check is specific owner has already confirme the operation.
-   * @param _operation The operation identifier.
-   * @param _owner The owner address.
-   * @return True if the owner has confirmed and false otherwise.
-   */
-  function hasConfirmed(bytes32 _operation, address _owner) constant returns (bool) {
-    var pending = pendings[_operation];
-    uint index = ownerIndex[_owner];
-
-    // make sure they're an owner
-    if (index == 0) {
-      return false;
-    }
-
-    // determine the bit to set for this owner.
-    uint ownerIndexBit = 2**index;
-    return !(pending.ownersDone & ownerIndexBit == 0);
-  }
-
-  /**
-   * @dev Confirm and operation and checks if it's already executable.
-   * @param _operation The operation identifier.
-   * @return Returns true when operation can be executed.
-   */
-  function confirmAndCheck(bytes32 _operation) internal returns (bool) {
-    // determine what index the present sender is:
-    uint index = ownerIndex[msg.sender];
-    // make sure they're an owner
-    if (index == 0) {
-      throw;
-    }
-
-    var pending = pendings[_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 = required;
-      // reset which owners have confirmed (none) - set our bitmap to 0.
-      pending.ownersDone = 0;
-      pending.index = pendingsIndex.length++;
-      pendingsIndex[pending.index] = _operation;
-    }
-    // determine the bit to set for this owner.
-    uint ownerIndexBit = 2**index;
-    // 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 pendingsIndex[pendings[_operation].index];
-        delete pendings[_operation];
-        return true;
-      } else {
-        // not enough: record that this owner in particular confirmed.
-        pending.yetNeeded--;
-        pending.ownersDone |= ownerIndexBit;
-      }
-    }
-    return false;
-  }
-
-
-  /**
-   * @dev Clear the pending list.
-   */
-  function clearPending() internal {
-    uint length = pendingsIndex.length;
-    for (uint i = 0; i < length; ++i) {
-      if (pendingsIndex[i] != 0) {
-        delete pendings[pendingsIndex[i]];
-      }
-    }
-    delete pendingsIndex;
-  }
-
-}

contracts/payment/PullPayment.sol

 pragma solidity ^0.4.11;
 
 
-import '../SafeMath.sol';
+import '../math/SafeMath.sol';
 
 
 /**
@@ -10,17 +10,17 @@ import '../SafeMath.sol';
  * contract and use asyncSend instead of send.
  */
 contract PullPayment {
-  using SafeMath for uint;
+  using SafeMath for uint256;
 
-  mapping(address => uint) public payments;
-  uint public totalPayments;
+  mapping(address => uint256) public payments;
+  uint256 public totalPayments;
 
   /**
   * @dev Called by the payer to store the sent amount as credit to be pulled.
   * @param dest The destination address of the funds.
   * @param amount The amount to transfer.
   */
-  function asyncSend(address dest, uint amount) internal {
+  function asyncSend(address dest, uint256 amount) internal {
     payments[dest] = payments[dest].add(amount);
     totalPayments = totalPayments.add(amount);
   }
@@ -28,23 +28,16 @@ contract PullPayment {
   /**
   * @dev withdraw accumulated balance, called by payee.
   */
-  function withdrawPayments() {
+  function withdrawPayments() public {
     address payee = msg.sender;
-    uint payment = payments[payee];
+    uint256 payment = payments[payee];
 
-    if (payment == 0) {
-      throw;
-    }
-
-    if (this.balance < payment) {
-      throw;
-    }
+    require(payment != 0);
+    require(this.balance >= payment);
 
     totalPayments = totalPayments.sub(payment);
     payments[payee] = 0;
 
-    if (!payee.send(payment)) {
-      throw;
-    }
+    assert(payee.send(payment));
   }
 }

contracts/token/BasicToken.sol

@@ -2,7 +2,7 @@ pragma solidity ^0.4.11;
 
 
 import './ERC20Basic.sol';
-import '../SafeMath.sol';
+import '../math/SafeMath.sol';
 
 
 /**
@@ -10,37 +10,31 @@ import '../SafeMath.sol';
  * @dev Basic version of StandardToken, with no allowances.
  */
 contract BasicToken is ERC20Basic {
-  using SafeMath for uint;
+  using SafeMath for uint256;
 
-  mapping(address => uint) balances;
-
-  /**
-   * @dev Fix for the ERC20 short address attack.
-   */
-  modifier onlyPayloadSize(uint size) {
-     if(msg.data.length < size + 4) {
-       throw;
-     }
-     _;
-  }
+  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, uint _value) onlyPayloadSize(2 * 32) {
+  function transfer(address _to, uint256 _value) public returns (bool) {
+    require(_to != address(0));
+
+    // 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 uint representing the amount owned by the passed address.
+  * @return An uint256 representing the amount owned by the passed address.
   */
-  function balanceOf(address _owner) constant returns (uint balance) {
+  function balanceOf(address _owner) public constant returns (uint256 balance) {
     return balances[_owner];
   }
 

contracts/token/BurnableToken.sol

+pragma solidity ^0.4.13;
+
+import './StandardToken.sol';
+
+/**
+ * @title Burnable Token
+ * @dev Token that can be irreversibly burned (destroyed).
+ */
+contract BurnableToken is StandardToken {
+
+    event Burn(address indexed burner, uint256 value);
+
+    /**
+     * @dev Burns a specific amount of tokens.
+     * @param _value The amount of token to be burned.
+     */
+    function burn(uint256 _value) public {
+        require(_value > 0);
+
+        address burner = msg.sender;
+        balances[burner] = balances[burner].sub(_value);
+        totalSupply = totalSupply.sub(_value);
+        Burn(burner, _value);
+    }
+}

contracts/token/CrowdsaleToken.sol

-pragma solidity ^0.4.11;
-
-
-import "./StandardToken.sol";
-
-
-/**
- * @title CrowdsaleToken
- *
- * @dev Simple ERC20 Token example, with crowdsale token creation
- * @dev IMPORTANT NOTE: do not use or deploy this contract as-is. It needs some changes to be 
- * production ready.
- */
-contract CrowdsaleToken is StandardToken {
-
-  string public constant name = "CrowdsaleToken";
-  string public constant symbol = "CRW";
-  uint public constant decimals = 18;
-  // replace with your fund collection multisig address
-  address public constant multisig = 0x0;
-
-
-  // 1 ether = 500 example tokens
-  uint public constant PRICE = 500;
-
-  /**
-   * @dev Fallback function which receives ether and sends the appropriate number of tokens to the 
-   * msg.sender.
-   */
-  function () payable {
-    createTokens(msg.sender);
-  }
-
-  /**
-   * @dev Creates tokens and send to the specified address.
-   * @param recipient The address which will recieve the new tokens.
-   */
-  function createTokens(address recipient) payable {
-    if (msg.value == 0) {
-      throw;
-    }
-
-    uint tokens = msg.value.mul(getPrice());
-    totalSupply = totalSupply.add(tokens);
-
-    balances[recipient] = balances[recipient].add(tokens);
-
-    if (!multisig.send(msg.value)) {
-      throw;
-    }
-  }
-
-  /**
-   * @dev replace this with any other price function
-   * @return The price per unit of token. 
-   */
-  function getPrice() constant returns (uint result) {
-    return PRICE;
-  }
-}

contracts/token/ERC20.sol

@@ -9,8 +9,8 @@ import './ERC20Basic.sol';
  * @dev see https://github.com/ethereum/EIPs/issues/20
  */
 contract ERC20 is ERC20Basic {
-  function allowance(address owner, address spender) constant returns (uint);
-  function transferFrom(address from, address to, uint value);
-  function approve(address spender, uint value);
-  event Approval(address indexed owner, address indexed spender, uint value);
+  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);
 }

contracts/token/ERC20Basic.sol

@@ -4,11 +4,11 @@ pragma solidity ^0.4.11;
 /**
  * @title ERC20Basic
  * @dev Simpler version of ERC20 interface
- * @dev see https://github.com/ethereum/EIPs/issues/20
+ * @dev see https://github.com/ethereum/EIPs/issues/179
  */
 contract ERC20Basic {
-  uint public totalSupply;
-  function balanceOf(address who) constant returns (uint);
-  function transfer(address to, uint value);
-  event Transfer(address indexed from, address indexed to, uint value);
+  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);
 }

contracts/token/LimitedTransferToken.sol

@@ -22,28 +22,28 @@ contract LimitedTransferToken is ERC20 {
   /**
    * @dev Checks whether it can transfer or otherwise throws.
    */
-  modifier canTransfer(address _sender, uint _value) {
-   if (_value > transferableTokens(_sender, uint64(now))) throw;
+  modifier canTransfer(address _sender, uint256 _value) {
+   require(_value <= transferableTokens(_sender, uint64(now)));
    _;
   }
 
   /**
    * @dev Checks modifier and allows transfer if tokens are not locked.
-   * @param _to The address that will recieve the tokens.
+   * @param _to The address that will receive the tokens.
    * @param _value The amount of tokens to be transferred.
    */
-  function transfer(address _to, uint _value) canTransfer(msg.sender, _value) {
-    super.transfer(_to, _value);
+  function transfer(address _to, uint256 _value) canTransfer(msg.sender, _value) public returns (bool) {
+    return super.transfer(_to, _value);
   }
 
   /**
   * @dev Checks modifier and allows transfer if tokens are not locked.
   * @param _from The address that will send the tokens.
-  * @param _to The address that will recieve the tokens.
+  * @param _to The address that will receive the tokens.
   * @param _value The amount of tokens to be transferred.
   */
-  function transferFrom(address _from, address _to, uint _value) canTransfer(_from, _value) {
-    super.transferFrom(_from, _to, _value);
+  function transferFrom(address _from, address _to, uint256 _value) canTransfer(_from, _value) public returns (bool) {
+    return super.transferFrom(_from, _to, _value);
   }
 
   /**
@@ -51,7 +51,7 @@ contract LimitedTransferToken is ERC20 {
    * @dev Overwriting transferableTokens(address holder, uint64 time) is the way to provide the
    * specific logic for limiting token transferability for a holder over time.
    */
-  function transferableTokens(address holder, uint64 time) constant public returns (uint256) {
+  function transferableTokens(address holder, uint64 time) public constant returns (uint256) {
     return balanceOf(holder);
   }
 }

contracts/token/MintableToken.sol

@@ -14,28 +14,28 @@ import '../ownership/Ownable.sol';
  */
 
 contract MintableToken is StandardToken, Ownable {
-  event Mint(address indexed to, uint value);
+  event Mint(address indexed to, uint256 amount);
   event MintFinished();
 
   bool public mintingFinished = false;
-  uint public totalSupply = 0;
 
 
   modifier canMint() {
-    if(mintingFinished) throw;
+    require(!mintingFinished);
     _;
   }
 
   /**
    * @dev Function to mint tokens
-   * @param _to The address that will recieve the minted tokens.
+   * @param _to The address that will receive the minted tokens.
    * @param _amount The amount of tokens to mint.
    * @return A boolean that indicates if the operation was successful.
    */
-  function mint(address _to, uint _amount) onlyOwner canMint returns (bool) {
+  function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
     totalSupply = totalSupply.add(_amount);
     balances[_to] = balances[_to].add(_amount);
     Mint(_to, _amount);
+    Transfer(0x0, _to, _amount);
     return true;
   }
 
@@ -43,7 +43,7 @@ contract MintableToken is StandardToken, Ownable {
    * @dev Function to stop minting new tokens.
    * @return True if the operation was successful.
    */
-  function finishMinting() onlyOwner returns (bool) {
+  function finishMinting() onlyOwner public returns (bool) {
     mintingFinished = true;
     MintFinished();
     return true;

contracts/token/PausableToken.sol

@@ -4,22 +4,18 @@ import './StandardToken.sol';
 import '../lifecycle/Pausable.sol';
 
 /**
- * Pausable token
+ * @title Pausable token
  *
- * Simple ERC20 Token example, with pausable token creation
- * Issue:
- * https://github.com/OpenZeppelin/zeppelin-solidity/issues/194
- * Based on code by BCAPtoken:
- * https://github.com/BCAPtoken/BCAPToken/blob/5cb5e76338cc47343ba9268663a915337c8b268e/sol/BCAPToken.sol#L27
+ * @dev StandardToken modified with pausable transfers.
  **/
 
-contract PausableToken is Pausable, StandardToken {
+contract PausableToken is StandardToken, Pausable {
 
-  function transfer(address _to, uint _value) whenNotPaused {
-    super.transfer(_to, _value);
+  function transfer(address _to, uint256 _value) whenNotPaused public returns (bool) {
+    return super.transfer(_to, _value);
   }
 
-  function transferFrom(address _from, address _to, uint _value) whenNotPaused {
-    super.transferFrom(_from, _to, _value);
+  function transferFrom(address _from, address _to, uint256 _value) whenNotPaused public returns (bool) {
+    return super.transferFrom(_from, _to, _value);
   }
 }

contracts/token/SafeERC20.sol

+pragma solidity ^0.4.11;
+
+import './ERC20Basic.sol';
+import './ERC20.sol';
+
+/**
+ * @title SafeERC20
+ * @dev Wrappers around ERC20 operations that throw on failure.
+ * To use this library you can add a `using SafeERC20 for ERC20;` statement to your contract,
+ * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
+ */
+library SafeERC20 {
+  function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
+    assert(token.transfer(to, value));
+  }
+
+  function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal {
+    assert(token.transferFrom(from, to, value));
+  }
+
+  function safeApprove(ERC20 token, address spender, uint256 value) internal {
+    assert(token.approve(spender, value));
+  }
+}

contracts/token/StandardToken.sol

@@ -8,58 +8,87 @@ import './ERC20.sol';
 /**
  * @title Standard ERC20 token
  *
- * @dev Implemantation of the basic standart 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 BasicToken, ERC20 {
+contract StandardToken is ERC20, BasicToken {
 
-  mapping (address => mapping (address => uint)) allowed;
+  mapping (address => mapping (address => uint256)) 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 uint the amout of tokens to be transfered
+   * @param _value uint256 the amount of tokens to be transferred
    */
-  function transferFrom(address _from, address _to, uint _value) onlyPayloadSize(3 * 32) {
+  function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
+    require(_to != address(0));
+
     var _allowance = allowed[_from][msg.sender];
 
     // Check is not needed because sub(_allowance, _value) will already throw if this condition is not met
-    // if (_value > _allowance) throw;
+    // require (_value <= _allowance);
 
-    balances[_to] = balances[_to].add(_value);
     balances[_from] = balances[_from].sub(_value);
+    balances[_to] = balances[_to].add(_value);
     allowed[_from][msg.sender] = _allowance.sub(_value);
     Transfer(_from, _to, _value);
+    return true;
   }
 
   /**
-   * @dev Aprove the passed address to spend the specified amount of tokens on beahlf of msg.sender.
+   * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
    * @param _spender The address which will spend the funds.
    * @param _value The amount of tokens to be spent.
    */
-  function approve(address _spender, uint _value) {
+  function approve(address _spender, uint256 _value) public returns (bool) {
 
     // To change the approve amount you first have to reduce the addresses`
     //  allowance to zero by calling `approve(_spender, 0)` if it is not
     //  already 0 to mitigate the race condition described here:
     //  https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
-    if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw;
+    require((_value == 0) || (allowed[msg.sender][_spender] == 0));
 
     allowed[msg.sender][_spender] = _value;
     Approval(msg.sender, _spender, _value);
+    return true;
   }
 
   /**
-   * @dev Function to check the amount of tokens than an owner allowed to a spender.
+   * @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 uint specifing the amount of tokens still avaible for the spender.
+   * @return A uint256 specifying the amount of tokens still available for the spender.
    */
-  function allowance(address _owner, address _spender) constant returns (uint remaining) {
+  function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
     return allowed[_owner][_spender];
   }
 
+  /**
+   * approve should be called when allowed[_spender] == 0. To increment
+   * allowed value is better to use this function to avoid 2 calls (and wait until
+   * the first transaction is mined)
+   * From MonolithDAO Token.sol
+   */
+  function increaseApproval (address _spender, uint _addedValue)
+    returns (bool success) {
+    allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
+    Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+    return true;
+  }
+
+  function decreaseApproval (address _spender, uint _subtractedValue)
+    returns (bool success) {
+    uint oldValue = allowed[msg.sender][_spender];
+    if (_subtractedValue > oldValue) {
+      allowed[msg.sender][_spender] = 0;
+    } else {
+      allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
+    }
+    Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+    return true;
+  }
+
 }

contracts/token/TokenTimelock.sol

+pragma solidity ^0.4.11;
+
+
+import './ERC20Basic.sol';
+import "../token/SafeERC20.sol";
+
+/**
+ * @title TokenTimelock
+ * @dev TokenTimelock is a token holder contract that will allow a
+ * beneficiary to extract the tokens after a given release time
+ */
+contract TokenTimelock {
+  using SafeERC20 for ERC20Basic;
+
+  // ERC20 basic token contract being held
+  ERC20Basic public token;
+
+  // beneficiary of tokens after they are released
+  address public beneficiary;
+
+  // timestamp when token release is enabled
+  uint64 public releaseTime;
+
+  function TokenTimelock(ERC20Basic _token, address _beneficiary, uint64 _releaseTime) {
+    require(_releaseTime > now);
+    token = _token;
+    beneficiary = _beneficiary;
+    releaseTime = _releaseTime;
+  }
+
+  /**
+   * @notice Transfers tokens held by timelock to beneficiary.
+   * Deprecated: please use TokenTimelock#release instead.
+   */
+  function claim() public {
+    require(msg.sender == beneficiary);
+    release();
+  }
+
+  /**
+   * @notice Transfers tokens held by timelock to beneficiary.
+   */
+  function release() public {
+    require(now >= releaseTime);
+
+    uint256 amount = token.balanceOf(this);
+    require(amount > 0);
+
+    token.safeTransfer(beneficiary, amount);
+  }
+}

contracts/token/VestedToken.sol

 pragma solidity ^0.4.11;
 
+import "../math/Math.sol";
 import "./StandardToken.sol";
 import "./LimitedTransferToken.sol";
 
@@ -44,13 +45,11 @@ contract VestedToken is StandardToken, LimitedTransferToken {
   ) public {
 
     // Check for date inconsistencies that may cause unexpected behavior
-    if (_cliff < _start || _vesting < _cliff) {
-      throw;
-    }
+    require(_cliff >= _start && _vesting >= _cliff);
 
-    if (tokenGrantsCount(_to) > MAX_GRANTS_PER_ADDRESS) throw;   // To prevent a user being spammed and have his balance locked (out of gas attack when calculating vesting).
+    require(tokenGrantsCount(_to) < MAX_GRANTS_PER_ADDRESS);   // To prevent a user being spammed and have his balance locked (out of gas attack when calculating vesting).
 
-    uint count = grants[_to].push(
+    uint256 count = grants[_to].push(
                 TokenGrant(
                   _revokable ? msg.sender : 0, // avoid storing an extra 20 bytes when it is non-revokable
                   _value,
@@ -72,16 +71,11 @@ contract VestedToken is StandardToken, LimitedTransferToken {
    * @param _holder The address which will have its tokens revoked.
    * @param _grantId The id of the token grant.
    */
-  function revokeTokenGrant(address _holder, uint _grantId) public {
-    TokenGrant grant = grants[_holder][_grantId];
-
-    if (!grant.revokable) { // Check if grant was revokable
-      throw;
-    }
+  function revokeTokenGrant(address _holder, uint256 _grantId) public {
+    TokenGrant storage grant = grants[_holder][_grantId];
 
-    if (grant.granter != msg.sender) { // Only granter can revoke it
-      throw;
-    }
+    require(grant.revokable);
+    require(grant.granter == msg.sender); // Only granter can revoke it
 
     address receiver = grant.burnsOnRevoke ? 0xdead : msg.sender;
 
@@ -103,12 +97,12 @@ contract VestedToken is StandardToken, LimitedTransferToken {
    * @dev Calculate the total amount of transferable tokens of a holder at a given time
    * @param holder address The address of the holder
    * @param time uint64 The specific time.
-   * @return An uint representing a holder's total amount of transferable tokens.
+   * @return An uint256 representing a holder's total amount of transferable tokens.
    */
-  function transferableTokens(address holder, uint64 time) constant public returns (uint256) {
+  function transferableTokens(address holder, uint64 time) public constant returns (uint256) {
     uint256 grantIndex = tokenGrantsCount(holder);
 
-    if (grantIndex == 0) return balanceOf(holder); // shortcut for holder without grants
+    if (grantIndex == 0) return super.transferableTokens(holder, time); // shortcut for holder without grants
 
     // Iterate through all the grants the holder has, and add all non-vested tokens
     uint256 nonVested = 0;
@@ -121,26 +115,26 @@ contract VestedToken is StandardToken, LimitedTransferToken {
 
     // Return the minimum of how many vested can transfer and other value
     // in case there are other limiting transferability factors (default is balanceOf)
-    return SafeMath.min256(vestedTransferable, super.transferableTokens(holder, time));
+    return Math.min256(vestedTransferable, super.transferableTokens(holder, time));
   }
 
   /**
    * @dev Check the amount of grants that an address has.
    * @param _holder The holder of the grants.
-   * @return A uint representing the total amount of grants.
+   * @return A uint256 representing the total amount of grants.
    */
-  function tokenGrantsCount(address _holder) constant returns (uint index) {
+  function tokenGrantsCount(address _holder) public constant returns (uint256 index) {
     return grants[_holder].length;
   }
 
   /**
-   * @dev Calculate amount of vested tokens at a specifc time.
-   * @param tokens uint256 The amount of tokens grantted.
+   * @dev Calculate amount of vested tokens at a specific time
+   * @param tokens uint256 The amount of tokens granted
    * @param time uint64 The time to be checked
-   * @param start uint64 A time representing the begining of the grant
-   * @param cliff uint64 The cliff period.
-   * @param vesting uint64 The vesting period.
-   * @return An uint representing the amount of vested tokensof a specif grant.
+   * @param start uint64 The time representing the beginning of the grant
+   * @param cliff uint64  The cliff period, the period before nothing can be paid out
+   * @param vesting uint64 The vesting period
+   * @return An uint256 representing the amount of vested tokens of a specific grant
    *  transferableTokens
    *   |                         _/--------   vestedTokens rect
    *   |                       _/
@@ -155,14 +149,14 @@ contract VestedToken is StandardToken, LimitedTransferToken {
    *   |      .        |
    *   |    .          |
    *   +===+===========+---------+----------> time
-   *      Start       Clift    Vesting
+   *      Start       Cliff    Vesting
    */
   function calculateVestedTokens(
     uint256 tokens,
     uint256 time,
     uint256 start,
     uint256 cliff,
-    uint256 vesting) constant returns (uint256)
+    uint256 vesting) public constant returns (uint256)
     {
       // Shortcuts for before cliff and after vesting cases.
       if (time < cliff) return 0;
@@ -172,7 +166,7 @@ contract VestedToken is StandardToken, LimitedTransferToken {
       // As before cliff the shortcut returns 0, we can use just calculate a value
       // in the vesting rect (as shown in above's figure)
 
-      // vestedTokens = tokens * (time - start) / (vesting - start)
+      // vestedTokens = (tokens * (time - start)) / (vesting - start)
       uint256 vestedTokens = SafeMath.div(
                                     SafeMath.mul(
                                       tokens,
@@ -185,14 +179,14 @@ contract VestedToken is StandardToken, LimitedTransferToken {
   }
 
   /**
-   * @dev Get all information about a specifc grant.
+   * @dev Get all information about a specific grant.
    * @param _holder The address which will have its tokens revoked.
    * @param _grantId The id of the token grant.
    * @return Returns all the values that represent a TokenGrant(address, value, start, cliff,
    * revokability, burnsOnRevoke, and vesting) plus the vested value at the current time.
    */
-  function tokenGrant(address _holder, uint _grantId) constant returns (address granter, uint256 value, uint256 vested, uint64 start, uint64 cliff, uint64 vesting, bool revokable, bool burnsOnRevoke) {
-    TokenGrant grant = grants[_holder][_grantId];
+  function tokenGrant(address _holder, uint256 _grantId) public constant returns (address granter, uint256 value, uint256 vested, uint64 start, uint64 cliff, uint64 vesting, bool revokable, bool burnsOnRevoke) {
+    TokenGrant storage grant = grants[_holder][_grantId];
 
     granter = grant.granter;
     value = grant.value;
@@ -209,7 +203,7 @@ contract VestedToken is StandardToken, LimitedTransferToken {
    * @dev Get the amount of vested tokens at a specific time.
    * @param grant TokenGrant The grant to be checked.
    * @param time The time to be checked
-   * @return An uint representing the amount of vested tokens of a specific grant at a specific time.
+   * @return An uint256 representing the amount of vested tokens of a specific grant at a specific time.
    */
   function vestedTokens(TokenGrant grant, uint64 time) private constant returns (uint256) {
     return calculateVestedTokens(
@@ -225,7 +219,7 @@ contract VestedToken is StandardToken, LimitedTransferToken {
    * @dev Calculate the amount of non vested tokens at a specific time.
    * @param grant TokenGrant The grant to be checked.
    * @param time uint64 The time to be checked
-   * @return An uint representing the amount of non vested tokens of a specifc grant on the 
+   * @return An uint256 representing the amount of non vested tokens of a specific grant on the
    * passed time frame.
    */
   function nonVestedTokens(TokenGrant grant, uint64 time) private constant returns (uint256) {
@@ -233,15 +227,15 @@ contract VestedToken is StandardToken, LimitedTransferToken {
   }
 
   /**
-   * @dev Calculate the date when the holder can trasfer all its tokens
+   * @dev Calculate the date when the holder can transfer all its tokens
    * @param holder address The address of the holder
-   * @return An uint representing the date of the last transferable tokens.
+   * @return An uint256 representing the date of the last transferable tokens.
    */
-  function lastTokenIsTransferableDate(address holder) constant public returns (uint64 date) {
+  function lastTokenIsTransferableDate(address holder) public constant returns (uint64 date) {
     date = uint64(now);
     uint256 grantIndex = grants[holder].length;
     for (uint256 i = 0; i < grantIndex; i++) {
-      date = SafeMath.max64(grants[holder][i].vesting, date);
+      date = Math.max64(grants[holder][i].vesting, date);
     }
   }
 }

docs/source/crowdsaletoken.rst

-CrowdsaleToken
-=============================================
-
-Simple ERC20 Token example, with crowdsale token creation.
-
-Inherits from contract StandardToken.
-
-createTokens(address recipient) payable
-"""""""""""""""""""""""""""""""""""""""""
-Creates tokens based on message value and credits to the recipient.
-
-getPrice() constant returns (uint result)
-"""""""""""""""""""""""""""""""""""""""""
-Returns the amount of tokens per 1 ether.
\ No newline at end of file

docs/source/ecrecovery.rst

+ECReovery
+=============================================
+
+Returns the signer of the the hash using the signature divided in v, r, and s values.
+
+recover(bytes32 hash, bytes sig) internal returns (address)
+"""""""""""""""""""""""""""""""""""""""""""""""""
+
+Returns the signer of the the hash using the signature that provides the web3.eth.sign() method.

docs/source/getting-started.rst

@@ -13,7 +13,7 @@ To install the Zeppelin library, run::
 
 After that, you'll get all the library's contracts in the contracts/zeppelin folder. You can use the contracts in the library like so::
 
-	import "./zeppelin/Ownable.sol";
+	import "zeppelin-solidity/contracts/Ownable.sol";
 
 	contract MyContract is Ownable {
 	  ...

docs/source/limitbalance.rst

@@ -5,7 +5,7 @@ Base contract that provides mechanism for limiting the amount of funds a contrac
 
 LimitBalance(unit _limit)
 """"""""""""""""""""""""""""
-Constructor takes an unisgned integer and sets it as the limit of funds this contract can hold.
+Constructor takes an unsigned integer and sets it as the limit of funds this contract can hold.
 
 modifier limitedPayable()
 """"""""""""""""""""""""""""

docs/source/math.rst

+Math
+=============================================
+
+Provides assorted low-level math operations.
+
+max64(uint64 a, uint64 b) internal constant returns (uint64)
+"""""""""""""""""""""""""""""""""""""""""""""""""
+
+Returns the largest of two uint64 numbers.
+
+min64(uint64 a, uint64 b) internal constant returns (uint64)
+"""""""""""""""""""""""""""""""""""""""""""""""""
+
+Returns the smallest of two uint64 numbers.
+
+max64(uint256 a, uint256 b) internal constant returns (uint256)
+"""""""""""""""""""""""""""""""""""""""""""""""""
+
+Returns the largest of two uint256 numbers.
+
+min64(uint256 a, uint256 b) internal constant returns (uint256)
+"""""""""""""""""""""""""""""""""""""""""""""""""
+
+Returns the smallest of two uint256 numbers.

docs/source/ownable.rst

@@ -11,6 +11,6 @@ modifier onlyOwner( )
 """"""""""""""""""""""""""""""""""""""
 Prevents function from running if it is called by anyone other than the owner.
 
-transfer(address newOwner) onlyOwner
+transferOwnership(address newOwner) onlyOwner
 """"""""""""""""""""""""""""""""""""""
 Transfers ownership of the contract to the passed address.

docs/source/pullpayment.rst

@@ -9,4 +9,4 @@ Adds sent amount to available balance that payee can pull from this contract, ca
 
 withdrawPayments( )
 """""""""""""""""""""""""""""""""""""""""""""""
-Sends designated balance to payee calling the contract. Throws error if designated balance is 0, if contract does not hold enough funds ot pay the payee, or if the send transaction is not successful.
+Sends designated balance to payee calling the contract. Throws error if designated balance is 0, if contract does not hold enough funds to pay the payee, or if the send transaction is not successful.
\ No newline at end of file

docs/source/safemath.rst

@@ -8,17 +8,17 @@ assert(bool assertion) internal
 
 Throws an error if the passed result is false. Used in this contract by checking mathematical expressions.
 
-safeMul(uint a, uint b) internal returns (uint)
+mul(uint256 a, uint256 b) internal returns (uint256)
 """""""""""""""""""""""""""""""""""""""""""""""""
 
-Multiplies two unisgned integers. Asserts that dividing the product by the non-zero multiplicand results in the multiplier.
+Multiplies two unsigned integers. Asserts that dividing the product by the non-zero multiplicand results in the multiplier.
 
-safeSub(uint a, uint b) internal returns (uint)
+sub(uint256 a, uint256 b) internal returns (uint256)
 """""""""""""""""""""""""""""""""""""""""""""""""
 
 Checks that b is not greater than a before subtracting.
 
-safeAdd(uint a, uint b) internal returns (uint)
+add(uint256 a, uint256 b) internal returns (uint256)
 """""""""""""""""""""""""""""""""""""""""""""""""
 
 Checks that the result is greater than both a and b.

ethpm.json

 {
   "package_name": "zeppelin",
-  "version": "1.0.7",
+  "version": "1.2.0",
   "description": "Secure Smart Contract library for Solidity",
   "authors": [
     "Manuel Araoz <manuelaraoz@gmail.com>"

package.json

 {
   "name": "zeppelin-solidity",
-  "version": "1.0.7",
+  "version": "1.2.0",
   "description": "Secure Smart Contract library for Solidity",
-  "main": "truffle.js",
   "scripts": {
     "test": "scripts/test.sh",
     "console": "truffle console",
-    "install": "scripts/install.sh",
-    "coverage": "scripts/coverage.sh",
-    "coveralls": "scripts/coveralls.sh"
+    "coverage": "scripts/coverage.sh"
   },
   "repository": {
     "type": "git",
@@ -28,19 +25,21 @@
     "url": "https://github.com/OpenZeppelin/zeppelin-solidity/issues"
   },
   "homepage": "https://github.com/OpenZeppelin/zeppelin-solidity",
-  "dependencies": {
-    "truffle-hdwallet-provider": "0.0.3"
-  },
   "devDependencies": {
+    "babel-polyfill": "^6.23.0",
     "babel-preset-es2015": "^6.18.0",
     "babel-preset-stage-2": "^6.18.0",
     "babel-preset-stage-3": "^6.17.0",
     "babel-register": "^6.23.0",
+    "chai": "^4.0.2",
+    "chai-as-promised": "^7.0.0",
+    "chai-bignumber": "^2.0.0",
     "coveralls": "^2.13.1",
-    "ethereumjs-testrpc": "^3.0.2",
     "ethereumjs-util": "^5.1.2",
+    "ethereumjs-testrpc": "^4.1.1",
     "mocha-lcov-reporter": "^1.3.0",
-    "solidity-coverage": "^0.1.0",
-    "truffle": "3.2.2"
+    "solidity-coverage": "^0.2.2",
+    "truffle": "^3.4.6",
+    "truffle-hdwallet-provider": "0.0.3"
   }
 }

scripts/coverage.sh

-#! /bin/bash
+#!/usr/bin/env bash
 
-SOLIDITY_COVERAGE=true ./node_modules/.bin/solidity-coverage
+SOLIDITY_COVERAGE=true scripts/test.sh

scripts/coveralls.sh

-#! /bin/bash
-
-yarn run coverage && cat coverage/lcov.info | ./node_modules/coveralls/bin/coveralls.js
-

scripts/install.sh

-#! /bin/bash
-
-mkdir -p ../../contracts/zeppelin && cp -r contracts/* "$_"

scripts/test.sh

-#! /bin/bash
-
-output=$(nc -z localhost 8545; echo $?)
-[ $output -eq "0" ] && trpc_running=true
-if [ ! $trpc_running ]; then
-  echo "Starting our own testrpc node instance"
-  testrpc > /dev/null &
-  trpc_pid=$!
+#!/usr/bin/env bash
+
+# Exit script as soon as a command fails.
+set -o errexit
+
+# Executes cleanup function at script exit.
+trap cleanup EXIT
+
+cleanup() {
+  # Kill the testrpc instance that we started (if we started one and if it's still running).
+  if [ -n "$testrpc_pid" ] && ps -p $testrpc_pid > /dev/null; then
+    kill -9 $testrpc_pid
+  fi
+}
+
+if [ "$SOLIDITY_COVERAGE" = true ]; then
+  testrpc_port=8555
+else
+  testrpc_port=8545
+fi
+
+testrpc_running() {
+  nc -z localhost "$testrpc_port"
+}
+
+testrpc() {
+  if [ "$SOLIDITY_COVERAGE" = true ]; then
+    node_modules/.bin/testrpc-sc --gasLimit 0xfffffffffff --port "$testrpc_port" "$@"
+  else
+    node_modules/.bin/testrpc "$@"
+  fi
+}
+
+if testrpc_running; then
+  echo "Using existing testrpc instance"
+else
+  echo "Starting our own testrpc instance"
+  # We define 10 accounts with balance 1M ether, needed for high-value tests.
+  testrpc \
+    --account="0x2bdd21761a483f71054e14f5b827213567971c676928d9a1808cbfa4b7501200,1000000000000000000000000"  \
+    --account="0x2bdd21761a483f71054e14f5b827213567971c676928d9a1808cbfa4b7501201,1000000000000000000000000"  \
+    --account="0x2bdd21761a483f71054e14f5b827213567971c676928d9a1808cbfa4b7501202,1000000000000000000000000"  \
+    --account="0x2bdd21761a483f71054e14f5b827213567971c676928d9a1808cbfa4b7501203,1000000000000000000000000"  \
+    --account="0x2bdd21761a483f71054e14f5b827213567971c676928d9a1808cbfa4b7501204,1000000000000000000000000"  \
+    --account="0x2bdd21761a483f71054e14f5b827213567971c676928d9a1808cbfa4b7501205,1000000000000000000000000"  \
+    --account="0x2bdd21761a483f71054e14f5b827213567971c676928d9a1808cbfa4b7501206,1000000000000000000000000"  \
+    --account="0x2bdd21761a483f71054e14f5b827213567971c676928d9a1808cbfa4b7501207,1000000000000000000000000"  \
+    --account="0x2bdd21761a483f71054e14f5b827213567971c676928d9a1808cbfa4b7501208,1000000000000000000000000"  \
+    --account="0x2bdd21761a483f71054e14f5b827213567971c676928d9a1808cbfa4b7501209,1000000000000000000000000"  \
+  > /dev/null &
+  testrpc_pid=$!
 fi
-./node_modules/truffle/cli.js test
-if [ ! $trpc_running ]; then
-  kill -9 $trpc_pid
+
+if [ "$SOLIDITY_COVERAGE" = true ]; then
+  node_modules/.bin/solidity-coverage
+
+  if [ "$CONTINUOUS_INTEGRATION" = true ]; then
+    cat coverage/lcov.info | node_modules/.bin/coveralls
+  fi
+else
+  node_modules/.bin/truffle test "$@"
 fi

test/BasicToken.js

@@ -22,14 +22,24 @@ contract('BasicToken', function(accounts) {
     assert.equal(secondAccountBalance, 100);
   });
 
-  it("should throw an error when trying to transfer more than balance", async function() {
+  it('should throw an error when trying to transfer more than balance', async function() {
     let token = await BasicTokenMock.new(accounts[0], 100);
     try {
       let transfer = await token.transfer(accounts[1], 101);
+      assert.fail('should have thrown before');
     } catch(error) {
-      return assertJump(error);
+      assertJump(error);
     }
+  });
+
+  it('should throw an error when trying to transfer to 0x0', async function() {
+    let token = await BasicTokenMock.new(accounts[0], 100);
+    try {
+      let transfer = await token.transfer(0x0, 100);
       assert.fail('should have thrown before');
+    } catch(error) {
+      assertJump(error);
+    }
   });
 
 });

test/BurnableToken.js

+'use strict'
+
+const EVMThrow = require('./helpers/EVMThrow.js')
+const BurnableTokenMock = artifacts.require("./helpers/BurnableTokenMock.sol")
+const BigNumber = web3.BigNumber
+
+require('chai')
+  .use(require('chai-as-promised'))
+  .use(require('chai-bignumber')(BigNumber))
+  .should()
+
+const expect = require('chai').expect
+
+contract('BurnableToken', function (accounts) {
+    let token
+    let expectedTokenSupply = new BigNumber(999)
+
+    beforeEach(async function () {
+        token = await BurnableTokenMock.new(accounts[0], 1000)
+    })
+
+    it('owner should be able to burn tokens', async function () {
+        const { logs } = await token.burn(1, { from: accounts[0] })
+
+        const balance = await token.balanceOf(accounts[0])
+        balance.should.be.bignumber.equal(expectedTokenSupply)
+
+        const totalSupply = await token.totalSupply()
+        totalSupply.should.be.bignumber.equal(expectedTokenSupply)
+
+        const event = logs.find(e => e.event === 'Burn')
+        expect(event).to.exist
+    })
+
+    it('cannot burn more tokens than your balance', async function () {
+        await token.burn(2000, { from: accounts[0] })
+        .should.be.rejectedWith(EVMThrow)
+    })
+})

test/CanReclaimToken.js

+'use strict';
+import expectThrow from './helpers/expectThrow';
+import toPromise from './helpers/toPromise';
+const CanReclaimToken = artifacts.require('../contracts/ownership/CanReclaimToken.sol');
+const BasicTokenMock = artifacts.require("./helpers/BasicTokenMock.sol");
+
+contract('CanReclaimToken', function(accounts) {
+  let token = null;
+  let canReclaimToken = null;
+
+  beforeEach(async function() {
+    // Create contract and token
+    token = await BasicTokenMock.new(accounts[0], 100);
+    canReclaimToken = await CanReclaimToken.new();
+    // Force token into contract
+    await token.transfer(canReclaimToken.address, 10);
+    const startBalance = await token.balanceOf(canReclaimToken.address);
+    assert.equal(startBalance, 10);
+  });
+
+  it('should allow owner to reclaim tokens', async function() {
+    const ownerStartBalance = await token.balanceOf(accounts[0]);
+    await canReclaimToken.reclaimToken(token.address);
+    const ownerFinalBalance = await token.balanceOf(accounts[0]);
+    const finalBalance = await token.balanceOf(canReclaimToken.address);
+    assert.equal(finalBalance, 0);
+    assert.equal(ownerFinalBalance - ownerStartBalance, 10);
+  });
+
+  it('should allow only owner to reclaim tokens', async function() {
+    await expectThrow(
+      canReclaimToken.reclaimToken(token.address, {from: accounts[1]}),
+    );
+  });
+});

test/CappedCrowdsale.js

+import ether from './helpers/ether'
+import {advanceBlock} from './helpers/advanceToBlock'
+import {increaseTimeTo, duration} from './helpers/increaseTime'
+import latestTime from './helpers/latestTime'
+import EVMThrow from './helpers/EVMThrow'
+
+const BigNumber = web3.BigNumber
+
+require('chai')
+  .use(require('chai-as-promised'))
+  .use(require('chai-bignumber')(BigNumber))
+  .should()
+
+const CappedCrowdsale = artifacts.require('./helpers/CappedCrowdsaleImpl.sol')
+const MintableToken = artifacts.require('MintableToken')
+
+contract('CappedCrowdsale', function ([_, wallet]) {
+
+  const rate = new BigNumber(1000)
+
+  const cap = ether(300)
+  const lessThanCap = ether(60)
+
+  before(async function() {
+    //Advance to the next block to correctly read time in the solidity "now" function interpreted by testrpc
+    await advanceBlock()
+  })
+
+  beforeEach(async function () {
+    this.startTime = latestTime() + duration.weeks(1);
+    this.endTime =   this.startTime + duration.weeks(1);
+
+    this.crowdsale = await CappedCrowdsale.new(this.startTime, this.endTime, rate, wallet, cap)
+
+    this.token = MintableToken.at(await this.crowdsale.token())
+  })
+
+  describe('creating a valid crowdsale', function () {
+
+    it('should fail with zero cap', async function () {
+      await CappedCrowdsale.new(this.startTime, this.endTime, rate, wallet, 0).should.be.rejectedWith(EVMThrow);
+    })
+
+  });
+
+  describe('accepting payments', function () {
+
+    beforeEach(async function () {
+      await increaseTimeTo(this.startTime)
+    })
+
+    it('should accept payments within cap', async function () {
+      await this.crowdsale.send(cap.minus(lessThanCap)).should.be.fulfilled
+      await this.crowdsale.send(lessThanCap).should.be.fulfilled
+    })
+
+    it('should reject payments outside cap', async function () {
+      await this.crowdsale.send(cap)
+      await this.crowdsale.send(1).should.be.rejectedWith(EVMThrow)
+    })
+
+    it('should reject payments that exceed cap', async function () {
+      await this.crowdsale.send(cap.plus(1)).should.be.rejectedWith(EVMThrow)
+    })
+
+  })
+
+  describe('ending', function () {
+
+    beforeEach(async function () {
+      await increaseTimeTo(this.startTime)
+    })
+
+    it('should not be ended if under cap', async function () {
+      let hasEnded = await this.crowdsale.hasEnded()
+      hasEnded.should.equal(false)
+      await this.crowdsale.send(lessThanCap)
+      hasEnded = await this.crowdsale.hasEnded()
+      hasEnded.should.equal(false)
+    })
+
+    it('should not be ended if just under cap', async function () {
+      await this.crowdsale.send(cap.minus(1))
+      let hasEnded = await this.crowdsale.hasEnded()
+      hasEnded.should.equal(false)
+    })
+
+    it('should be ended if cap reached', async function () {
+      await this.crowdsale.send(cap)
+      let hasEnded = await this.crowdsale.hasEnded()
+      hasEnded.should.equal(true)
+    })
+
+  })
+
+})

test/Claimable.js

@@ -26,6 +26,7 @@ contract('Claimable', function(accounts) {
   it('should prevent to claimOwnership from no pendingOwner', async function() {
     try {
       await claimable.claimOwnership({from: accounts[2]});
+      assert.fail('should have thrown before');
     } catch(error) {
       assertJump(error);
     }
@@ -37,6 +38,7 @@ contract('Claimable', function(accounts) {
     assert.isTrue(owner !== other);
     try {
       await claimable.transferOwnership(other, {from: other});
+      assert.fail('should have thrown before');
     } catch(error) {
       assertJump(error);
     }

test/Crowdsale.js

+import ether from './helpers/ether'
+import {advanceBlock} from './helpers/advanceToBlock'
+import {increaseTimeTo, duration} from './helpers/increaseTime'
+import latestTime from './helpers/latestTime'
+import EVMThrow from './helpers/EVMThrow'
+
+const BigNumber = web3.BigNumber
+
+const should = require('chai')
+  .use(require('chai-as-promised'))
+  .use(require('chai-bignumber')(BigNumber))
+  .should()
+
+const Crowdsale = artifacts.require('Crowdsale')
+const MintableToken = artifacts.require('MintableToken')
+
+contract('Crowdsale', function ([_, investor, wallet, purchaser]) {
+
+  const rate = new BigNumber(1000)
+  const value = ether(42)
+
+  const expectedTokenAmount = rate.mul(value)
+
+  before(async function() {
+    //Advance to the next block to correctly read time in the solidity "now" function interpreted by testrpc
+    await advanceBlock()
+  })
+
+  beforeEach(async function () {
+    this.startTime = latestTime() + duration.weeks(1);
+    this.endTime =   this.startTime + duration.weeks(1);
+    this.afterEndTime = this.endTime + duration.seconds(1)
+
+
+    this.crowdsale = await Crowdsale.new(this.startTime, this.endTime, rate, wallet)
+
+    this.token = MintableToken.at(await this.crowdsale.token())
+  })
+
+  it('should be token owner', async function () {
+    const owner = await this.token.owner()
+    owner.should.equal(this.crowdsale.address)
+  })
+
+  it('should be ended only after end', async function () {
+    let ended = await this.crowdsale.hasEnded()
+    ended.should.equal(false)
+    await increaseTimeTo(this.afterEndTime)
+    ended = await this.crowdsale.hasEnded()
+    ended.should.equal(true)
+  })
+
+  describe('accepting payments', function () {
+
+    it('should reject payments before start', async function () {
+      await this.crowdsale.send(value).should.be.rejectedWith(EVMThrow)
+      await this.crowdsale.buyTokens(investor, {from: purchaser, value: value}).should.be.rejectedWith(EVMThrow)
+    })
+
+    it('should accept payments after start', async function () {
+      await increaseTimeTo(this.startTime)
+      await this.crowdsale.send(value).should.be.fulfilled
+      await this.crowdsale.buyTokens(investor, {value: value, from: purchaser}).should.be.fulfilled
+    })
+
+    it('should reject payments after end', async function () {
+      await increaseTimeTo(this.afterEndTime)
+      await this.crowdsale.send(value).should.be.rejectedWith(EVMThrow)
+      await this.crowdsale.buyTokens(investor, {value: value, from: purchaser}).should.be.rejectedWith(EVMThrow)
+    })
+
+  })
+
+  describe('high-level purchase', function () {
+
+    beforeEach(async function() {
+      await increaseTimeTo(this.startTime)
+    })
+
+    it('should log purchase', async function () {
+      const {logs} = await this.crowdsale.sendTransaction({value: value, from: investor})
+
+      const event = logs.find(e => e.event === 'TokenPurchase')
+
+      should.exist(event)
+      event.args.purchaser.should.equal(investor)
+      event.args.beneficiary.should.equal(investor)
+      event.args.value.should.be.bignumber.equal(value)
+      event.args.amount.should.be.bignumber.equal(expectedTokenAmount)
+    })
+
+    it('should increase totalSupply', async function () {
+      await this.crowdsale.send(value)
+      const totalSupply = await this.token.totalSupply()
+      totalSupply.should.be.bignumber.equal(expectedTokenAmount)
+    })
+
+    it('should assign tokens to sender', async function () {
+      await this.crowdsale.sendTransaction({value: value, from: investor})
+      let balance = await this.token.balanceOf(investor);
+      balance.should.be.bignumber.equal(expectedTokenAmount)
+    })
+
+    it('should forward funds to wallet', async function () {
+      const pre = web3.eth.getBalance(wallet)
+      await this.crowdsale.sendTransaction({value, from: investor})
+      const post = web3.eth.getBalance(wallet)
+      post.minus(pre).should.be.bignumber.equal(value)
+    })
+
+  })
+
+  describe('low-level purchase', function () {
+
+    beforeEach(async function() {
+      await increaseTimeTo(this.startTime)
+    })
+
+    it('should log purchase', async function () {
+      const {logs} = await this.crowdsale.buyTokens(investor, {value: value, from: purchaser})
+
+      const event = logs.find(e => e.event === 'TokenPurchase')
+
+      should.exist(event)
+      event.args.purchaser.should.equal(purchaser)
+      event.args.beneficiary.should.equal(investor)
+      event.args.value.should.be.bignumber.equal(value)
+      event.args.amount.should.be.bignumber.equal(expectedTokenAmount)
+    })
+
+    it('should increase totalSupply', async function () {
+      await this.crowdsale.buyTokens(investor, {value, from: purchaser})
+      const totalSupply = await this.token.totalSupply()
+      totalSupply.should.be.bignumber.equal(expectedTokenAmount)
+    })
+
+    it('should assign tokens to beneficiary', async function () {
+      await this.crowdsale.buyTokens(investor, {value, from: purchaser})
+      const balance = await this.token.balanceOf(investor)
+      balance.should.be.bignumber.equal(expectedTokenAmount)
+    })
+
+    it('should forward funds to wallet', async function () {
+      const pre = web3.eth.getBalance(wallet)
+      await this.crowdsale.buyTokens(investor, {value, from: purchaser})
+      const post = web3.eth.getBalance(wallet)
+      post.minus(pre).should.be.bignumber.equal(value)
+    })
+
+  })
+
+})

test/DayLimit.js

 'use strict';
 const assertJump = require('./helpers/assertJump');
+const timer = require('./helpers/timer');
 
-var DayLimitMock = artifacts.require('helpers/DayLimitMock.sol');
+var DayLimitMock = artifacts.require('./helpers/DayLimitMock.sol');
 
 contract('DayLimit', function(accounts) {
+  const day = 60 * 60 * 24;
 
-  it('should construct with the passed daily limit', async function() {
+  let dayLimit;
   let initLimit = 10;
-    let dayLimit = await DayLimitMock.new(initLimit);
+
+  beforeEach( async function() {
+    dayLimit = await DayLimitMock.new(initLimit);
+  });
+
+  it('should construct with the passed daily limit', async function() {
     let dailyLimit = await dayLimit.dailyLimit();
     assert.equal(initLimit, dailyLimit);
   });
 
   it('should be able to spend if daily limit is not reached', async function() {
-    let limit = 10;
-    let dayLimit = await DayLimitMock.new(limit);
-
     await dayLimit.attemptSpend(8);
     let spentToday = await dayLimit.spentToday();
     assert.equal(spentToday, 8);
@@ -26,30 +30,26 @@ contract('DayLimit', function(accounts) {
   });
 
   it('should prevent spending if daily limit is reached', async function() {
-    let limit = 10;
-    let dayLimit = await DayLimitMock.new(limit);
-
     await dayLimit.attemptSpend(8);
     let spentToday = await dayLimit.spentToday();
     assert.equal(spentToday, 8);
 
     try {
       await dayLimit.attemptSpend(3);
+      assert.fail('should have thrown before');
     } catch(error) {
       assertJump(error);
     }
   });
 
   it('should allow spending if daily limit is reached and then set higher', async function() {
-    let limit = 10;
-    let dayLimit = await DayLimitMock.new(limit);
-
     await dayLimit.attemptSpend(8);
     let spentToday = await dayLimit.spentToday();
     assert.equal(spentToday, 8);
 
     try {
       await dayLimit.attemptSpend(3);
+      assert.fail('should have thrown before');
     } catch(error) {
       assertJump(error);
     }
@@ -63,6 +63,26 @@ contract('DayLimit', function(accounts) {
   });
 
   it('should allow spending if daily limit is reached and then amount spent is reset', async function() {
+    await dayLimit.attemptSpend(8);
+    let spentToday = await dayLimit.spentToday();
+    assert.equal(spentToday, 8);
+
+    try {
+      await dayLimit.attemptSpend(3);
+      assert.fail('should have thrown before');
+    } catch(error) {
+      assertJump(error);
+    }
+    spentToday = await dayLimit.spentToday();
+    assert.equal(spentToday, 8);
+
+    await dayLimit.resetSpentToday();
+    await dayLimit.attemptSpend(3);
+    spentToday = await dayLimit.spentToday();
+    assert.equal(spentToday, 3);
+  });
+
+  it('should allow spending if daily limit is reached and then the next has come', async function() {
     let limit = 10;
     let dayLimit = await DayLimitMock.new(limit);
 
@@ -72,13 +92,15 @@ contract('DayLimit', function(accounts) {
 
     try {
       await dayLimit.attemptSpend(3);
+      assert.fail('should have thrown before');
     } catch(error) {
       assertJump(error);
     }
     spentToday = await dayLimit.spentToday();
     assert.equal(spentToday, 8);
 
-    await dayLimit.resetSpentToday(15);
+    await timer(day);
+
     await dayLimit.attemptSpend(3);
     spentToday = await dayLimit.spentToday();
     assert.equal(spentToday, 3);

test/ECRecovery.js

+var ECRecovery = artifacts.require("../contracts/ECRecovery.sol");
+var utils = require('ethereumjs-util');
+var hashMessage = require('./helpers/hashMessage.js');
+
+contract('ECRecovery', function(accounts) {
+
+  let ecrecovery;
+
+  before(async function() {
+    ecrecovery = await ECRecovery.new();
+  });
+
+  it("recover v0", async function() {
+    // Signature generated outside testrpc with method web3.eth.sign(signer, message)
+    let signer = '0x2cc1166f6212628a0deef2b33befb2187d35b86c';
+    let message = '0x7dbaf558b0a1a5dc7a67202117ab143c1d8605a983e4a743bc06fcc03162dc0d'; // web3.sha3('OpenZeppelin')
+    let signature = '0x5d99b6f7f6d1f73d1a26497f2b1c89b24c0993913f86e9a2d02cd69887d9c94f3c880358579d811b21dd1b7fd9bb01c1d81d10e69f0384e675c32b39643be89200';
+    assert.equal(signer, await ecrecovery.recover(message, signature));
+  });
+
+  it("recover v1", async function() {
+    // Signature generated outside testrpc with method web3.eth.sign(signer, message)
+    let signer = '0x1e318623ab09fe6de3c9b8672098464aeda9100e';
+    let message = '0x7dbaf558b0a1a5dc7a67202117ab143c1d8605a983e4a743bc06fcc03162dc0d'; // web3.sha3('OpenZeppelin')
+    let signature = '0x331fe75a821c982f9127538858900d87d3ec1f9f737338ad67cad133fa48feff48e6fa0c18abc62e42820f05943e47af3e9fbe306ce74d64094bdf1691ee53e001';
+    assert.equal(signer, await ecrecovery.recover(message, signature));
+  });
+
+  it("recover using web3.eth.sign()", async function() {
+    // Create the signature using account[0]
+    const signature = web3.eth.sign(web3.eth.accounts[0], web3.sha3('OpenZeppelin'));
+
+    // Recover the signer address form the generated message and signature.
+    assert.equal(web3.eth.accounts[0], await ecrecovery.recover(hashMessage('OpenZeppelin'), signature));
+  });
+
+  it("recover using web3.eth.sign() should return wrong signer", async function() {
+    // Create the signature using account[0]
+    const signature = web3.eth.sign(web3.eth.accounts[0], web3.sha3('OpenZeppelin'));
+
+    // Recover the signer address form the generated message and wrong signature.
+    assert.notEqual(web3.eth.accounts[0], await ecrecovery.recover(hashMessage('Test'), signature));
+  });
+
+  it("recover should fail when a wrong hash is sent", async function() {
+    // Create the signature using account[0]
+    let signature = web3.eth.sign(web3.eth.accounts[0], web3.sha3('OpenZeppelin'));
+
+    // Recover the signer address form the generated message and wrong signature.
+    assert.equal('0x0000000000000000000000000000000000000000',
+      await ecrecovery.recover(hashMessage('OpenZeppelin').substring(2), signature)
+    );
+  });
+
+});

test/FinalizableCrowdsale.js

+import {advanceBlock} from './helpers/advanceToBlock'
+import {increaseTimeTo, duration} from './helpers/increaseTime'
+import latestTime from './helpers/latestTime'
+import EVMThrow from './helpers/EVMThrow'
+
+const BigNumber = web3.BigNumber
+
+const should = require('chai')
+  .use(require('chai-as-promised'))
+  .use(require('chai-bignumber')(BigNumber))
+  .should()
+
+const FinalizableCrowdsale = artifacts.require('./helpers/FinalizableCrowdsaleImpl.sol')
+const MintableToken = artifacts.require('MintableToken')
+
+contract('FinalizableCrowdsale', function ([_, owner, wallet, thirdparty]) {
+
+  const rate = new BigNumber(1000)
+
+  before(async function() {
+    //Advance to the next block to correctly read time in the solidity "now" function interpreted by testrpc
+    await advanceBlock()
+  })
+
+  beforeEach(async function () {
+    this.startTime = latestTime() + duration.weeks(1)
+    this.endTime =   this.startTime + duration.weeks(1)
+    this.afterEndTime = this.endTime + duration.seconds(1)
+
+
+    this.crowdsale = await FinalizableCrowdsale.new(this.startTime, this.endTime, rate, wallet, {from: owner})
+
+    this.token = MintableToken.at(await this.crowdsale.token())
+  })
+
+  it('cannot be finalized before ending', async function () {
+    await this.crowdsale.finalize({from: owner}).should.be.rejectedWith(EVMThrow)
+  })
+
+  it('cannot be finalized by third party after ending', async function () {
+    await increaseTimeTo(this.afterEndTime)
+    await this.crowdsale.finalize({from: thirdparty}).should.be.rejectedWith(EVMThrow)
+  })
+
+  it('can be finalized by owner after ending', async function () {
+    await increaseTimeTo(this.afterEndTime)
+    await this.crowdsale.finalize({from: owner}).should.be.fulfilled
+  })
+
+  it('cannot be finalized twice', async function () {
+    await increaseTimeTo(this.afterEndTime)
+    await this.crowdsale.finalize({from: owner})
+    await this.crowdsale.finalize({from: owner}).should.be.rejectedWith(EVMThrow)
+  })
+
+  it('logs finalized', async function () {
+    await increaseTimeTo(this.afterEndTime)
+    const {logs} = await this.crowdsale.finalize({from: owner})
+    const event = logs.find(e => e.event === 'Finalized')
+    should.exist(event)
+  })
+
+})

test/LimitBalance.js

@@ -28,10 +28,10 @@ contract('LimitBalance', function(accounts) {
     let amount = 1110;
     try {
       await lb.limitedDeposit({value: amount});
+      assert.fail('should have thrown before');
     } catch(error) {
-      return assertJump(error);
+      assertJump(error);
     }
-    assert.fail('should have thrown before');
   });
 
   it('should allow multiple sends below limit', async function() {
@@ -52,10 +52,10 @@ contract('LimitBalance', function(accounts) {
 
     try {
       await lb.limitedDeposit({value: amount+1});
+      assert.fail('should have thrown before');
     } catch(error) {
-      return assertJump(error);
+      assertJump(error);
     }
-    assert.fail('should have thrown before');
   });
 
 });

test/MintableToken.js

 'use strict';
 
-const assertJump = require('./helpers/assertJump');
+import expectThrow from './helpers/expectThrow';
 var MintableToken = artifacts.require('../contracts/Tokens/MintableToken.sol');
 
 contract('Mintable', function(accounts) {
@@ -23,7 +23,12 @@ contract('Mintable', function(accounts) {
   });
 
   it('should mint a given amount of tokens to a given address', async function() {
-    await token.mint(accounts[0], 100);
+    const result = await token.mint(accounts[0], 100);
+    assert.equal(result.logs[0].event, 'Mint');
+    assert.equal(result.logs[0].args.to.valueOf(), accounts[0]);
+    assert.equal(result.logs[0].args.amount.valueOf(), 100);
+    assert.equal(result.logs[1].event, 'Transfer');
+    assert.equal(result.logs[1].args.from.valueOf(), 0x0);
 
     let balance0 = await token.balanceOf(accounts[0]);
     assert(balance0, 100);
@@ -32,4 +37,10 @@ contract('Mintable', function(accounts) {
     assert(totalSupply, 100);
   })
 
+  it('should fail to mint after call to finishMinting', async function () {
+    await token.finishMinting();
+    assert.equal(await token.mintingFinished(), true);
+    await expectThrow(token.mint(accounts[0], 100));
+  })
+
 });

test/MultisigWallet.js

-'use strict';
-
-var MultisigWalletMock = artifacts.require('./helpers/MultisigWalletMock.sol');
-require('./helpers/transactionMined.js');
-
-contract('MultisigWallet', function(accounts) {
-  let shouldntFail = function(err) {
-    assert.isFalse(!!err);
-  };
-  it('should send balance to passed address upon death', async function() {
-    //Give account[0] 20 ether
-    web3.eth.sendTransaction({from: web3.eth.coinbase, to: accounts[0], value: web3.toWei('20','ether')}, shouldntFail);
-
-    let dailyLimit = 10;
-    let ownersRequired = 2;
-
-    //Create MultisigWallet contract with 10 ether
-    let wallet = await MultisigWalletMock.new(accounts, ownersRequired, dailyLimit, {value: web3.toWei('10', 'ether')});
-
-    //Get balances of owner and wallet after wallet creation.
-    let ownerBalance = web3.eth.getBalance(accounts[0]);
-    let walletBalance = web3.eth.getBalance(wallet.address);
-    let hash = 1234;
-
-    //Call destroy function from two different owner accounts, satisfying owners required
-    await wallet.destroy(accounts[0], {data: hash});
-    let txnHash = await wallet.destroy(accounts[0], {from: accounts[1], data: hash});
-
-    //Get balances of owner and wallet after destroy function is complete, compare with previous values
-    let newOwnerBalance = web3.eth.getBalance(accounts[0]);
-    let newWalletBalance = web3.eth.getBalance(wallet.address);
-
-    assert.isTrue(newOwnerBalance > ownerBalance);
-    assert.isTrue(newWalletBalance < walletBalance);
-  });
-
-  it('should execute transaction if below daily limit', async function() {
-    //Give account[0] 20 ether
-    web3.eth.sendTransaction({from: web3.eth.coinbase, to: accounts[0], value: web3.toWei('20','ether')}, shouldntFail);
-
-    let dailyLimit = 10;
-    let ownersRequired = 2;
-
-    //Create MultisigWallet contract with 10 ether
-    let wallet = await MultisigWalletMock.new(accounts, ownersRequired, dailyLimit, {value: web3.toWei('10', 'ether')});
-
-    let accountBalance = web3.eth.getBalance(accounts[2]);
-    let hash = 1234;
-
-    //Owner account0 commands wallet to send 9 wei to account2
-    let txnHash = await wallet.execute(accounts[2], 9, hash);
-
-    //Balance of account2 should have increased
-    let newAccountBalance = web3.eth.getBalance(accounts[2]);
-    assert.isTrue(newAccountBalance > accountBalance);
-  });
-
-  it('should prevent execution of transaction if above daily limit', async function() {
-    //Give account[0] 20 ether
-    web3.eth.sendTransaction({from: web3.eth.coinbase, to: accounts[0], value: web3.toWei('20','ether')}, shouldntFail);
-
-    let dailyLimit = 10;
-    let ownersRequired = 2;
-
-    //Create MultisigWallet contract with 10 ether
-    let wallet = await MultisigWalletMock.new(accounts, ownersRequired, dailyLimit, {value: web3.toWei('10', 'ether')});
-
-    let accountBalance = web3.eth.getBalance(accounts[2]);
-    let hash = 1234;
-
-    //Owner account0 commands wallet to send 9 wei to account2
-    let txnHash = await wallet.execute(accounts[2], 9, hash);
-
-    //Balance of account2 should have increased
-    let newAccountBalance = web3.eth.getBalance(accounts[2]);
-    assert.isTrue(newAccountBalance > accountBalance);
-
-    accountBalance = newAccountBalance;
-    hash = 4567;
-
-    //Owner account0 commands wallet to send 2 more wei to account2, going over the daily limit of 10
-    txnHash = await wallet.execute(accounts[2], 2, hash);
-
-    //Balance of account2 should not change
-    newAccountBalance = web3.eth.getBalance(accounts[2]);
-    assert.equal(newAccountBalance.toString(), accountBalance.toString());
-  });
-
-  it('should execute transaction if above daily limit and enough owners approve', async function() {
-    //Give account[0] 20 ether
-    web3.eth.sendTransaction({from: web3.eth.coinbase, to: accounts[0], value: web3.toWei('20','ether')}, shouldntFail);
-
-    let dailyLimit = 10;
-    let ownersRequired = 2;
-
-    //Create MultisigWallet contract with 10 ether
-    let wallet = await MultisigWalletMock.new(accounts, ownersRequired, dailyLimit, {value: web3.toWei('10', 'ether')});
-
-    let accountBalance = web3.eth.getBalance(accounts[2]);
-    let hash = 1234;
-
-    //Owner account0 commands wallet to send 11 wei to account2
-    let txnHash = await wallet.execute(accounts[2], 11, hash);
-
-    //Balance of account2 should not change
-    let newAccountBalance = web3.eth.getBalance(accounts[2]);
-    assert.equal(newAccountBalance.toString(), accountBalance.toString());
-
-    accountBalance = newAccountBalance;
-
-    //Owner account1 commands wallet to send 11 wei to account2
-    txnHash = await wallet.execute(accounts[2], 2, hash);
-
-    //Balance of account2 should change
-    newAccountBalance = web3.eth.getBalance(accounts[2]);
-    assert.isTrue(newAccountBalance > accountBalance);
-  });
-
-});

test/Ownable.js

@@ -29,6 +29,7 @@ contract('Ownable', function(accounts) {
     assert.isTrue(owner !== other);
     try {
       await ownable.transferOwnership(other, {from: other});
+      assert.fail('should have thrown before');
     } catch(error) {
       assertJump(error);
     }
@@ -36,10 +37,12 @@ contract('Ownable', function(accounts) {
 
   it('should guard ownership against stuck state', async function() {
     let originalOwner = await ownable.owner();
+    try {
       await ownable.transferOwnership(null, {from: originalOwner});
-    let newOwner = await ownable.owner();
-
-    assert.equal(originalOwner, newOwner);
+      assert.fail();
+    } catch(error) {
+      assertJump(error);
+    }
   });
 
 });

test/Pausable.js

@@ -23,6 +23,7 @@ contract('Pausable', function(accounts) {
 
     try {
       await Pausable.normalProcess();
+      assert.fail('should have thrown before');
     } catch(error) {
       assertJump(error);
     }
@@ -35,10 +36,10 @@ contract('Pausable', function(accounts) {
     let Pausable = await PausableMock.new();
     try {
       await Pausable.drasticMeasure();
+      assert.fail('should have thrown before');
     } catch(error) {
       assertJump(error);
     }
-
     const drasticMeasureTaken = await Pausable.drasticMeasureTaken();
     assert.isFalse(drasticMeasureTaken);
   });
@@ -62,4 +63,19 @@ contract('Pausable', function(accounts) {
     assert.equal(count0, 1);
   });
 
+  it('should prevent drastic measure after pause is over', async function() {
+    let Pausable = await PausableMock.new();
+    await Pausable.pause();
+    await Pausable.unpause();
+    try {
+      await Pausable.drasticMeasure();
+      assert.fail('should have thrown before');
+    } catch(error) {
+      assertJump(error);
+    }
+
+    const drasticMeasureTaken = await Pausable.drasticMeasureTaken();
+    assert.isFalse(drasticMeasureTaken);
+  });
+
 });

test/PausableToken.js

@@ -55,19 +55,19 @@ contract('PausableToken', function(accounts) {
     await token.pause();
     try {
       await token.transfer(accounts[1], 100);
+      assert.fail('should have thrown before');
     } catch (error) {
-      return assertJump(error);
+      assertJump(error);
     }
-    assert.fail('should have thrown before');
   });
 
   it('should throw an error trying to transfer from another account while transactions are paused', async function() {
     await token.pause();
     try {
       await token.transferFrom(accounts[0], accounts[1], 100);
+      assert.fail('should have thrown before');
     } catch (error) {
-      return assertJump(error);
+      assertJump(error);
     }
-    assert.fail('should have thrown before');
   });
 })

test/PullPayment.js

 var PullPaymentMock = artifacts.require("./helpers/PullPaymentMock.sol");
 
 contract('PullPayment', function(accounts) {
+  let ppce;
+  let amount = 17*1e18;
+
+  beforeEach(async function() {
+    ppce = await PullPaymentMock.new({value: amount});
+  });
 
   it("can't call asyncSend externally", async function() {
-    let ppc = await PullPaymentMock.new();
-    assert.isUndefined(ppc.asyncSend);
+    assert.isUndefined(ppce.asyncSend);
   });
 
   it("can record an async payment correctly", async function() {
     let AMOUNT = 100;
-    let ppce = await PullPaymentMock.new();
     let callSend = await ppce.callSend(accounts[0], AMOUNT);
     let paymentsToAccount0 = await ppce.payments(accounts[0]);
     let totalPayments = await ppce.totalPayments();
@@ -19,7 +23,6 @@ contract('PullPayment', function(accounts) {
   });
 
   it("can add multiple balances on one account", async function() {
-    let ppce = await PullPaymentMock.new();
     let call1 = await ppce.callSend(accounts[0], 200);
     let call2 = await ppce.callSend(accounts[0], 300);
     let paymentsToAccount0 = await ppce.payments(accounts[0]);
@@ -30,7 +33,6 @@ contract('PullPayment', function(accounts) {
   });
 
   it("can add balances on multiple accounts", async function() {
-    let ppce = await PullPaymentMock.new();
     let call1 = await ppce.callSend(accounts[0], 200);
     let call2 = await ppce.callSend(accounts[1], 300);
 
@@ -45,18 +47,16 @@ contract('PullPayment', function(accounts) {
   });
 
   it("can withdraw payment", async function() {
-    let AMOUNT = 17*1e18;
     let payee = accounts[1];
     let initialBalance = web3.eth.getBalance(payee);
 
-    let ppce = await PullPaymentMock.new({value: AMOUNT});
-    let call1 = await ppce.callSend(payee, AMOUNT);
+    let call1 = await ppce.callSend(payee, amount);
 
     let payment1 = await ppce.payments(payee);
-    assert.equal(payment1, AMOUNT);
+    assert.equal(payment1, amount);
 
     let totalPayments = await ppce.totalPayments();
-    assert.equal(totalPayments, AMOUNT);
+    assert.equal(totalPayments, amount);
 
     let withdraw = await ppce.withdrawPayments({from: payee});
     let payment2 = await ppce.payments(payee);
@@ -66,7 +66,7 @@ contract('PullPayment', function(accounts) {
     assert.equal(totalPayments, 0);
 
     let balance = web3.eth.getBalance(payee);
-    assert(Math.abs(balance-initialBalance-AMOUNT) < 1e16);
+    assert(Math.abs(balance-initialBalance-amount) < 1e16);
   });
 
 });

test/RefundVault.js

+const BigNumber = web3.BigNumber
+
+require('chai')
+  .use(require('chai-as-promised'))
+  .use(require('chai-bignumber')(BigNumber))
+  .should()
+
+import ether from './helpers/ether'
+import EVMThrow from './helpers/EVMThrow'
+
+const RefundVault = artifacts.require('RefundVault')
+
+contract('RefundVault', function ([_, owner, wallet, investor]) {
+
+  const value = ether(42)
+
+  beforeEach(async function () {
+    this.vault = await RefundVault.new(wallet, {from: owner})
+  })
+
+  it('should accept contributions', async function () {
+    await this.vault.deposit(investor, {value, from: owner}).should.be.fulfilled
+  })
+
+  it('should not refund contribution during active state', async function () {
+    await this.vault.deposit(investor, {value, from: owner})
+    await this.vault.refund(investor).should.be.rejectedWith(EVMThrow)
+  })
+
+  it('only owner can enter refund mode', async function () {
+    await this.vault.enableRefunds({from: _}).should.be.rejectedWith(EVMThrow)
+    await this.vault.enableRefunds({from: owner}).should.be.fulfilled
+  })
+
+  it('should refund contribution after entering refund mode', async function () {
+    await this.vault.deposit(investor, {value, from: owner})
+    await this.vault.enableRefunds({from: owner})
+
+    const pre = web3.eth.getBalance(investor)
+    await this.vault.refund(investor)
+    const post = web3.eth.getBalance(investor)
+
+    post.minus(pre).should.be.bignumber.equal(value)
+  })
+
+  it('only owner can close', async function () {
+    await this.vault.close({from: _}).should.be.rejectedWith(EVMThrow)
+    await this.vault.close({from: owner}).should.be.fulfilled
+  })
+
+  it('should forward funds to wallet after closing', async function () {
+    await this.vault.deposit(investor, {value, from: owner})
+
+    const pre = web3.eth.getBalance(wallet)
+    await this.vault.close({from: owner})
+    const post = web3.eth.getBalance(wallet)
+
+    post.minus(pre).should.be.bignumber.equal(value)
+  })
+
+})

test/RefundableCrowdsale.js

+import ether from './helpers/ether'
+import {advanceBlock} from './helpers/advanceToBlock'
+import {increaseTimeTo, duration} from './helpers/increaseTime'
+import latestTime from './helpers/latestTime'
+import EVMThrow from './helpers/EVMThrow'
+
+const BigNumber = web3.BigNumber
+
+require('chai')
+  .use(require('chai-as-promised'))
+  .use(require('chai-bignumber')(BigNumber))
+  .should()
+
+const RefundableCrowdsale = artifacts.require('./helpers/RefundableCrowdsaleImpl.sol')
+
+contract('RefundableCrowdsale', function ([_, owner, wallet, investor]) {
+
+  const rate = new BigNumber(1000)
+  const goal = ether(800)
+  const lessThanGoal = ether(750)
+
+  before(async function() {
+    //Advance to the next block to correctly read time in the solidity "now" function interpreted by testrpc
+    await advanceBlock()
+  })
+
+  beforeEach(async function () {
+    this.startTime = latestTime() + duration.weeks(1)
+    this.endTime =   this.startTime + duration.weeks(1)
+    this.afterEndTime = this.endTime + duration.seconds(1)
+
+    this.crowdsale = await RefundableCrowdsale.new(this.startTime, this.endTime, rate, wallet, goal, {from: owner})
+  })
+
+  describe('creating a valid crowdsale', function () {
+
+    it('should fail with zero goal', async function () {
+      await RefundableCrowdsale.new(this.startTime, this.endTime, rate, wallet, 0, {from: owner}).should.be.rejectedWith(EVMThrow);
+    })
+
+  });
+
+  it('should deny refunds before end', async function () {
+    await this.crowdsale.claimRefund({from: investor}).should.be.rejectedWith(EVMThrow)
+    await increaseTimeTo(this.startTime)
+    await this.crowdsale.claimRefund({from: investor}).should.be.rejectedWith(EVMThrow)
+  })
+
+  it('should deny refunds after end if goal was reached', async function () {
+    await increaseTimeTo(this.startTime)
+    await this.crowdsale.sendTransaction({value: goal, from: investor})
+    await increaseTimeTo(this.afterEndTime)
+    await this.crowdsale.claimRefund({from: investor}).should.be.rejectedWith(EVMThrow)
+  })
+
+  it('should allow refunds after end if goal was not reached', async function () {
+    await increaseTimeTo(this.startTime)
+    await this.crowdsale.sendTransaction({value: lessThanGoal, from: investor})
+    await increaseTimeTo(this.afterEndTime)
+
+    await this.crowdsale.finalize({from: owner})
+
+    const pre = web3.eth.getBalance(investor)
+    await this.crowdsale.claimRefund({from: investor, gasPrice: 0})
+			.should.be.fulfilled
+    const post = web3.eth.getBalance(investor)
+
+    post.minus(pre).should.be.bignumber.equal(lessThanGoal)
+  })
+
+  it('should forward funds to wallet after end if goal was reached', async function () {
+    await increaseTimeTo(this.startTime)
+    await this.crowdsale.sendTransaction({value: goal, from: investor})
+    await increaseTimeTo(this.afterEndTime)
+
+    const pre = web3.eth.getBalance(wallet)
+    await this.crowdsale.finalize({from: owner})
+    const post = web3.eth.getBalance(wallet)
+
+    post.minus(pre).should.be.bignumber.equal(goal)
+  })
+
+})

test/SafeERC20.js

+import EVMThrow from './helpers/EVMThrow';
+
+require('chai')
+  .use(require('chai-as-promised'))
+  .should();
+
+const SafeERC20Helper = artifacts.require('./helpers/SafeERC20Helper.sol');
+
+contract('SafeERC20', function () {
+
+  beforeEach(async function () {
+    this.helper = await SafeERC20Helper.new();
+  });
+
+  it('should throw on failed transfer', async function () {
+    await this.helper.doFailingTransfer().should.be.rejectedWith(EVMThrow);
+  });
+
+  it('should throw on failed transferFrom', async function () {
+    await this.helper.doFailingTransferFrom().should.be.rejectedWith(EVMThrow);
+  });
+
+  it('should throw on failed approve', async function () {
+    await this.helper.doFailingApprove().should.be.rejectedWith(EVMThrow);
+  });
+
+  it('should not throw on succeeding transfer', async function () {
+    await this.helper.doSucceedingTransfer().should.be.fulfilled;
+  });
+
+  it('should not throw on succeeding transferFrom', async function () {
+    await this.helper.doSucceedingTransferFrom().should.be.fulfilled;
+  });
+
+  it('should not throw on succeeding approve', async function () {
+    await this.helper.doSucceedingApprove().should.be.fulfilled;
+  });
+});

test/SafeMath.js

@@ -40,10 +40,10 @@ contract('SafeMath', function(accounts) {
     let b = 5678;
     try {
       let subtract = await safeMath.subtract(a, b);
+      assert.fail('should have thrown before');
     } catch(error) {
-      return assertJump(error);
+      assertJump(error);
     }
-    assert.fail('should have thrown before');
   });
 
   it("should throw an error on addition overflow", async function() {
@@ -51,10 +51,10 @@ contract('SafeMath', function(accounts) {
     let b = 1;
     try {
       let add = await safeMath.add(a, b);
+      assert.fail('should have thrown before');
     } catch(error) {
-      return assertJump(error);
+      assertJump(error);
     }
-    assert.fail('should have thrown before');
   });
 
   it("should throw an error on multiplication overflow", async function() {
@@ -62,10 +62,10 @@ contract('SafeMath', function(accounts) {
     let b = 2;
     try {
       let multiply = await safeMath.multiply(a, b);
+      assert.fail('should have thrown before');
     } catch(error) {
-      return assertJump(error);
+      assertJump(error);
     }
-    assert.fail('should have thrown before');
   });
 
 });

test/SampleCrowdsale.js

+import ether from './helpers/ether'
+import {advanceBlock} from './helpers/advanceToBlock'
+import {increaseTimeTo, duration} from './helpers/increaseTime'
+import latestTime from './helpers/latestTime'
+import EVMThrow from './helpers/EVMThrow'
+
+const BigNumber = web3.BigNumber;
+
+const should = require('chai')
+  .use(require('chai-as-promised'))
+  .use(require('chai-bignumber')(BigNumber))
+  .should();
+
+const SampleCrowdsale = artifacts.require('SampleCrowdsale');
+const SampleCrowdsaleToken = artifacts.require('SampleCrowdsaleToken');
+
+contract('Crowdsale', function ([owner, wallet, investor]) {
+
+  const RATE = new BigNumber(10);
+  const GOAL = ether(10);
+  const CAP  = ether(20);
+
+  before(async function() {
+    //Advance to the next block to correctly read time in the solidity "now" function interpreted by testrpc
+    await advanceBlock()
+  })
+
+  beforeEach(async function () {
+    this.startTime = latestTime() + duration.weeks(1);
+    this.endTime =   this.startTime + duration.weeks(1);
+    this.afterEndTime = this.endTime + duration.seconds(1);
+
+    this.crowdsale = await SampleCrowdsale.new(this.startTime, this.endTime, RATE, GOAL, CAP, wallet);
+    this.token = SampleCrowdsaleToken.at(await this.crowdsale.token());
+  });
+
+
+  it('should create crowdsale with correct parameters', async function () {
+    this.crowdsale.should.exist;
+    this.token.should.exist;
+
+    (await this.crowdsale.startTime()).should.be.bignumber.equal(this.startTime);
+    (await this.crowdsale.endTime()).should.be.bignumber.equal(this.endTime);
+    (await this.crowdsale.rate()).should.be.bignumber.equal(RATE);
+    (await this.crowdsale.wallet()).should.be.equal(wallet);
+    (await this.crowdsale.goal()).should.be.bignumber.equal(GOAL);
+    (await this.crowdsale.cap()).should.be.bignumber.equal(CAP);
+  });
+
+  it('should not accept payments before start', async function () {
+    await this.crowdsale.send(ether(1)).should.be.rejectedWith(EVMThrow);
+    await this.crowdsale.buyTokens(investor, {from: investor, value: ether(1)}).should.be.rejectedWith(EVMThrow);
+  });
+
+  it('should accept payments during the sale', async function () {
+    const investmentAmount = ether(1);
+    const expectedTokenAmount = RATE.mul(investmentAmount);
+
+    await increaseTimeTo(this.startTime);
+    await this.crowdsale.buyTokens(investor, {value: investmentAmount, from: investor}).should.be.fulfilled;
+
+    (await this.token.balanceOf(investor)).should.be.bignumber.equal(expectedTokenAmount);
+    (await this.token.totalSupply()).should.be.bignumber.equal(expectedTokenAmount);
+  });
+
+  it('should reject payments after end', async function () {
+    await increaseTimeTo(this.afterEnd);
+    await this.crowdsale.send(ether(1)).should.be.rejectedWith(EVMThrow);
+    await this.crowdsale.buyTokens(investor, {value: ether(1), from: investor}).should.be.rejectedWith(EVMThrow);
+  });
+
+  it('should reject payments over cap', async function () {
+    await increaseTimeTo(this.startTime);
+    await this.crowdsale.send(CAP);
+    await this.crowdsale.send(1).should.be.rejectedWith(EVMThrow);
+  });
+
+  it('should allow finalization and transfer funds to wallet if the goal is reached', async function () {
+    await increaseTimeTo(this.startTime);
+    await this.crowdsale.send(GOAL);
+
+    const beforeFinalization = web3.eth.getBalance(wallet);
+    await increaseTimeTo(this.afterEndTime);
+    await this.crowdsale.finalize({from: owner});
+    const afterFinalization = web3.eth.getBalance(wallet);
+
+    afterFinalization.minus(beforeFinalization).should.be.bignumber.equal(GOAL);
+  });
+
+  it('should allow refunds if the goal is not reached', async function () {
+    const balanceBeforeInvestment = web3.eth.getBalance(investor);
+
+    await increaseTimeTo(this.startTime);
+    await this.crowdsale.sendTransaction({value: ether(1), from: investor, gasPrice: 0});
+    await increaseTimeTo(this.afterEndTime);
+
+    await this.crowdsale.finalize({from: owner});
+    await this.crowdsale.claimRefund({from: investor, gasPrice: 0}).should.be.fulfilled;
+
+    const balanceAfterRefund = web3.eth.getBalance(investor);
+    balanceBeforeInvestment.should.be.bignumber.equal(balanceAfterRefund);
+  });
+
+});

test/Shareable.js

-var ShareableMock = artifacts.require("./helpers/ShareableMock.sol");
-
-contract('Shareable', function(accounts) {
-
-  it('should construct with correct owners and number of sigs required', async function() {
-    let requiredSigs = 2;
-    let owners = accounts.slice(1,4);
-    let shareable = await ShareableMock.new(owners, requiredSigs);
-
-    let required = await shareable.required();
-    assert.equal(required, requiredSigs);
-    let owner = await shareable.getOwner(0);
-    assert.equal(owner, accounts[0]);
-
-    for(let i = 0; i < accounts.length; i++) {
-      let owner = await shareable.getOwner(i);
-      let isowner = await shareable.isOwner(accounts[i]);
-      if(i <= owners.length) {
-        assert.equal(accounts[i], owner);
-        assert.isTrue(isowner);
-      } else {
-        assert.notEqual(accounts[i], owner);
-        assert.isFalse(isowner);
-      }
-    }
-  });
-
-  it('should only perform multisig function with enough sigs', async function() {
-    let requiredSigs = 3;
-    let owners = accounts.slice(1,4);
-    let shareable = await ShareableMock.new(owners, requiredSigs);
-    let hash = 1234;
-
-    let initCount = await shareable.count();
-    initCount = initCount.toString();
-
-    for(let i = 0; i < requiredSigs; i++) {
-      await shareable.increaseCount(hash, {from: accounts[i]});
-      let count = await shareable.count();
-      if(i == requiredSigs - 1) {
-        assert.equal(Number(initCount)+1, count.toString());
-      } else {
-        assert.equal(initCount, count.toString());
-      }
-    }
-  });
-
-  it('should require approval from different owners', async function() {
-    let requiredSigs = 2;
-    let owners = accounts.slice(1,4);
-    let shareable = await ShareableMock.new(owners, requiredSigs);
-    let hash = 1234;
-
-    let initCount = await shareable.count();
-    initCount = initCount.toString();
-
-    //Count shouldn't increase when the same owner calls repeatedly
-    for(let i = 0; i < 2; i++) {
-      await shareable.increaseCount(hash);
-      let count = await shareable.count();
-      assert.equal(initCount, count.toString());
-    }
-  });
-
-  it('should reset sig count after operation is approved', async function() {
-    let requiredSigs = 3;
-    let owners = accounts.slice(1,4);
-    let shareable = await ShareableMock.new(owners, requiredSigs);
-    let hash = 1234;
-
-    let initCount = await shareable.count();
-
-    for(let i = 0; i < requiredSigs * 3; i++) {
-      await shareable.increaseCount(hash, {from: accounts[i % 4]});
-      let count = await shareable.count();
-      if((i%(requiredSigs)) == requiredSigs - 1) {
-        initCount = Number(initCount)+1;
-        assert.equal(initCount, count);
-      } else {
-        assert.equal(initCount.toString(), count);
-      }
-    }
-  });
-
-  it('should not perform multisig function after an owner revokes', async function() {
-    let requiredSigs = 3;
-    let owners = accounts.slice(1,4);
-    let shareable = await ShareableMock.new(owners, requiredSigs);
-    let hash = 1234;
-
-    let initCount = await shareable.count();
-
-    for(let i = 0; i < requiredSigs; i++) {
-      if(i == 1) {
-        await shareable.revoke(hash, {from: accounts[i-1]});
-      }
-      await shareable.increaseCount(hash, {from: accounts[i]});
-      let count = await shareable.count();
-      assert.equal(initCount.toString(), count);
-    }
-  });
-
-});

test/StandardToken.js

@@ -5,8 +5,13 @@ var StandardTokenMock = artifacts.require('./helpers/StandardTokenMock.sol');
 
 contract('StandardToken', function(accounts) {
 
+  let token;
+
+  beforeEach(async function() {
+    token = await StandardTokenMock.new(accounts[0], 100);
+  });
+
   it('should return the correct totalSupply after construction', async function() {
-    let token = await StandardTokenMock.new(accounts[0], 100);
     let totalSupply = await token.totalSupply();
 
     assert.equal(totalSupply, 100);
@@ -34,10 +39,10 @@ contract('StandardToken', function(accounts) {
     let token = await StandardTokenMock.new(accounts[0], 100);
     try {
       await token.transfer(accounts[1], 101);
+      assert.fail('should have thrown before');
     } catch(error) {
-      return assertJump(error);
+      assertJump(error);
     }
-    assert.fail('should have thrown before');
   });
 
   it('should return correct balances after transfering from another account', async function() {
@@ -56,14 +61,52 @@ contract('StandardToken', function(accounts) {
   });
 
   it('should throw an error when trying to transfer more than allowed', async function() {
-    let token = await StandardTokenMock.new();
     await token.approve(accounts[1], 99);
     try {
       await token.transferFrom(accounts[0], accounts[2], 100, {from: accounts[1]});
+      assert.fail('should have thrown before');
     } catch (error) {
-      return assertJump(error);
+      assertJump(error);
+    }
+  });
+
+  describe('validating allowance updates to spender', function() {
+    let preApproved;
+
+    it('should start with zero', async function() {
+      preApproved = await token.allowance(accounts[0], accounts[1]);
+      assert.equal(preApproved, 0);
+    })
+
+    it('should increase by 50 then decrease by 10', async function() {
+      await token.increaseApproval(accounts[1], 50);
+      let postIncrease = await token.allowance(accounts[0], accounts[1]);
+      preApproved.plus(50).should.be.bignumber.equal(postIncrease);
+      await token.decreaseApproval(accounts[1], 10);
+      let postDecrease = await token.allowance(accounts[0], accounts[1]);
+      postIncrease.minus(10).should.be.bignumber.equal(postDecrease);
+    })
+  });
+
+  it('should throw an error when trying to transfer to 0x0', async function() {
+    let token = await StandardTokenMock.new(accounts[0], 100);
+    try {
+      let transfer = await token.transfer(0x0, 100);
+      assert.fail('should have thrown before');
+    } catch(error) {
+      assertJump(error);
     }
+  });
+
+  it('should throw an error when trying to transferFrom to 0x0', async function() {
+    let token = await StandardTokenMock.new(accounts[0], 100);
+    await token.approve(accounts[1], 100);
+    try {
+      let transfer = await token.transferFrom(accounts[0], 0x0, 100, {from: accounts[1]});
       assert.fail('should have thrown before');
+    } catch(error) {
+      assertJump(error);
+    }
   });
 
 });

test/TokenDestructible.js

@@ -5,9 +5,13 @@ var StandardTokenMock = artifacts.require("./helpers/StandardTokenMock.sol");
 require('./helpers/transactionMined.js');
 
 contract('TokenDestructible', function(accounts) {
+  let destructible;
+
+  beforeEach(async function() {
+    destructible = await TokenDestructible.new({fron: accounts[0], value: web3.toWei('10', 'ether')});
+  });
 
   it('should send balance to owner after destruction', async function() {
-    let destructible = await TokenDestructible.new({from: accounts[0], value: web3.toWei('10','ether')});
     let owner = await destructible.owner();
     let initBalance = web3.eth.getBalance(owner);
     await destructible.destroy([], {from: owner});
@@ -16,7 +20,6 @@ contract('TokenDestructible', function(accounts) {
   });
 
   it('should send tokens to owner after destruction', async function() {
-    let destructible = await TokenDestructible.new({from: accounts[0], value: web3.toWei('10','ether')});
     let owner = await destructible.owner();
     let token = await StandardTokenMock.new(destructible.address, 100);
     let initContractBalance = await token.balanceOf(destructible.address);