Basic idea

contracts/crowdsale-refactor/Crowdsale.sol

@@ -0,0 +1,109 @@
+pragma solidity ^0.4.18;
+
+import "../token/ERC20/MintableToken.sol";
+import "../math/SafeMath.sol";
+
+contract Crowdsale {
+  using SafeMath for uint256;
+
+  ERC20 public token;
+
+  uint256 public startTime;
+  uint256 public endTime;
+
+  address public wallet;
+  uint256 public rate;
+  uint256 public weiRaised;
+
+  event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
+
+  function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet, ERC20 _token) public {
+    require(_startTime >= now);
+    require(_endTime >= _startTime);
+    require(_rate > 0);
+    require(_wallet != address(0));
+    require(_token != address(0));
+
+    startTime = _startTime;
+    endTime = _endTime;
+    rate = _rate;
+    wallet = _wallet;
+    token = _token;
+  }
+
+  // -----------------------------------------
+  // Crowdsale external interface
+  // -----------------------------------------
+
+  function () external payable {
+    buyTokens(msg.sender);
+  }
+
+  function buyTokens(address beneficiary) public payable {
+
+    uint256 weiAmount = msg.value;
+    preValidatePurchase(beneficiary, weiAmount);
+
+    // calculate token amount to be created
+    uint256 tokens = getTokenAmount(weiAmount);
+
+    // update state
+    weiRaised = weiRaised.add(weiAmount);
+
+    processPurchase(beneficiary, tokens);
+    TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
+
+    forwardFunds();
+    postValidatePurchase(beneficiary, weiAmount);
+  }
+
+  function hasEnded() public view returns (bool) {
+    return now > endTime;
+  }
+
+  // -----------------------------------------
+  // Purchase validation
+  // -----------------------------------------
+
+  function preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
+    require(_beneficiary != address(0));
+    require(now >= startTime && now <= endTime);
+    require(_weiAmount != 0);
+  }
+
+  function postValidatePurchase(address beneficiary, uint256 weiAmount) internal {
+    // optional override
+  }
+
+  // -----------------------------------------
+  // Emission
+  // -----------------------------------------
+
+  function emitTokens(address _beneficiary, uint256 _tokenAmount) internal {
+    token.transfer(_beneficiary, _tokenAmount);
+  }
+
+  // -----------------------------------------
+  // Token distribution
+  // -----------------------------------------
+
+  function processPurchase(address _beneficiary, uint256 _tokenAmount) internal {
+    emitTokens(_beneficiary, _tokenAmount);
+  }
+
+  // -----------------------------------------
+  // Price calculation
+  // -----------------------------------------
+
+  function getTokenAmount(uint256 weiAmount) internal view returns (uint256) {
+    return weiAmount.mul(rate);
+  }
+
+  // -----------------------------------------
+  // Funds distribution
+  // -----------------------------------------
+
+  function forwardFunds() internal {
+    wallet.transfer(msg.value);
+  }
+}

contracts/crowdsale-refactor/calculation/VariablePriceCrowdsale.sol

@@ -0,0 +1 @@
+// TODO: overrides getTokenAmount()

contracts/crowdsale-refactor/distribution/FinalizableCrowdsale.sol

@@ -0,0 +1,41 @@
+pragma solidity ^0.4.18;
+
+import "../../math/SafeMath.sol";
+import "../../ownership/Ownable.sol";
+import "../CrowdsaleBase.sol";
+
+
+/**
+ * @title FinalizableCrowdsale
+ * @dev Extension of Crowdsale where an owner can do extra work
+ * after finishing.
+ */
+contract FinalizableCrowdsale is CrowdsaleBase, 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-refactor/distribution/PostDeliveryCrowdsale.sol

@@ -0,0 +1,21 @@
+pragma solidity ^0.4.18;
+
+import "../CrowdsaleBase.sol";
+import "../../token/ERC20/ERC20.sol";
+
+contract PostDeliveryCrowdsale is CrowdsaleBase {
+
+  mapping(address => uint256) promised;
+
+  function processPurchase(address _beneficiary, uint256 _tokenAmount) internal {
+    promises[_beneficiary] = promises[_beneficiary].add(_tokenAmount);
+  }
+
+  function withdrawTokens() public {
+    require(hasEnded());
+    uint256 amount = promises[msg.sender];
+    require(amount > 0);
+    promises[msg.sender] = 0;
+    emitTokens(msg.sender, amount);
+  }
+}

contracts/crowdsale-refactor/distribution/RefundableCrowdsale.sol

@@ -0,0 +1,60 @@
+pragma solidity ^0.4.18;
+
+
+import "../../math/SafeMath.sol";
+import "./FinalizableCrowdsale.sol";
+import "./utils/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) public {
+    require(_goal > 0);
+    vault = new RefundVault(wallet);
+    goal = _goal;
+  }
+
+  // if crowdsale is unsuccessful, investors can claim refunds here
+  function claimRefund() public {
+    require(isFinalized);
+    require(!goalReached());
+
+    vault.refund(msg.sender);
+  }
+
+  function goalReached() public view returns (bool) {
+    return weiRaised >= goal;
+  }
+
+  // vault finalization task, called when owner calls finalize()
+  function finalization() internal {
+    if (goalReached()) {
+      vault.close();
+    } else {
+      vault.enableRefunds();
+    }
+
+    super.finalization();
+  }
+
+  // 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);
+  }
+
+}

contracts/crowdsale-refactor/distribution/utils/RefundVault.sol

@@ -0,0 +1,57 @@
+pragma solidity ^0.4.18;
+
+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) public {
+    require(_wallet != address(0));
+    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-refactor/emission/ApprovedCrowdsale.sol

@@ -0,0 +1,23 @@
+pragma solidity ^0.4.18;
+
+import "../Crowdsale.sol";
+import "../../token/ERC20/ERC20.sol";
+
+contract ApprovedCrowdsale is Crowdsale {
+
+  ERC20 public token;
+  address public tokenOwner;
+
+  function ApprovedCrowdsale(ERC20 _token, address _tokenOwner) {
+    require(_token != address(0));
+    require(_tokenOwner != address(0));
+    token = _token;
+    tokenOwner = _tokenOwner;
+  }
+
+  // TODO: consider querying approval left and end crowdsale if depleted 
+
+  function emitTokens(address _beneficiary, uint256 _tokenAmount) internal {
+    token.transferFrom(tokenOwner, _beneficiary, _tokenAmount);
+  }
+}

contracts/crowdsale-refactor/emission/MintedCrowdsale.sol

@@ -0,0 +1,18 @@
+pragma solidity ^0.4.18;
+
+import "../CrowdsaleBase.sol";
+import "../../token/ERC20/MintableToken.sol";
+
+contract MintedCrowdsale is CrowdsaleBase {
+
+  MintableToken token;
+
+  function MintedCrowdsale(MintableToken _token) {
+    require(_token != address(0));
+    token = _token;
+  }
+
+  function emitTokens(address _beneficiary, uint256 _tokenAmount) internal {
+    token.mint(_beneficiary, _tokenAmount);
+  }
+}

contracts/crowdsale-refactor/validation/CappedCrowdsale.sol

@@ -0,0 +1,26 @@
+pragma solidity ^0.4.18;
+
+import "../../math/SafeMath.sol";
+import "../CrowdsaleBase.sol";
+
+contract CappedCrowdsale is CrowdsaleBase {
+  using SafeMath for uint256;
+
+  uint256 public cap;
+
+  function CappedCrowdsale(uint256 _cap) public {
+    require(_cap > 0);
+    cap = _cap;
+  }
+
+  function hasEnded() public view returns (bool) {
+    bool capReached = weiRaised >= cap;
+    return capReached || super.hasEnded();
+  }
+
+  function postValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
+    super.postValidatePurchase(_beneficiary, _weiAmount);
+    require(weiRaised <= cap);
+  }
+
+}

contracts/crowdsale-refactor/validation/UserCappedCrowdsale.sol

@@ -0,0 +1,28 @@
+pragma solidity ^ 0.4.18;
+
+import "../CrowdsaleBase.sol";
+import "../../ownership/Ownable.sol";
+
+contract UserCappedCrowdsale is CrowdsaleBase, Ownable {
+
+  mapping(address => uint256) public contributions;
+  mapping(address => uint256) public caps;
+
+  function setUserCap(address _beneficiary, uint256 _cap) external onlyOwner {
+    caps[_beneficiary] = _cap;
+  }
+
+  function getUserCap(address _beneficiary) public view returns (uint256) {
+    return caps[_beneficiary];
+  }
+
+  function getUserContribution(address _beneficiary) public view returns (uint256) {
+    return contributions[_beneficiary];
+  }
+
+  function postValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
+    super.postValidatePurchase(_beneficiary, _weiAmount);
+    contributions[_beneficiary] = contributions[_beneficiary].add(_weiAmount);
+    require(contributions[_beneficiary] <= caps[_beneficiary]);
+  }
+}