Escrows

contracts/crowdsale/distribution/RefundableCrowdsale.sol

@@ -3,31 +3,31 @@ pragma solidity ^0.4.24;
 
 import "../../math/SafeMath.sol";
 import "./FinalizableCrowdsale.sol";
-import "./utils/RefundVault.sol";
+import "../../payment/RefundEscrow.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.
+ * Uses a RefundEscrow as the crowdsale's escrow.
  */
 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;
+  // refund escrow used to hold funds while crowdsale is running
+  RefundEscrow public escrow;
 
   /**
-   * @dev Constructor, creates RefundVault.
+   * @dev Constructor, creates RefundEscrow.
    * @param _goal Funding goal
    */
   constructor(uint256 _goal) public {
     require(_goal > 0);
-    vault = new RefundVault(wallet);
+    escrow = new RefundEscrow(wallet);
     goal = _goal;
   }
 
@@ -38,7 +38,7 @@ contract RefundableCrowdsale is FinalizableCrowdsale {
     require(isFinalized);
     require(!goalReached());
 
-    vault.refund(msg.sender);
+    escrow.refund(msg.sender);
   }
 
   /**
@@ -50,23 +50,24 @@ contract RefundableCrowdsale is FinalizableCrowdsale {
   }
 
   /**
-   * @dev vault finalization task, called when owner calls finalize()
+   * @dev escrow finalization task, called when owner calls finalize()
    */
   function finalization() internal {
     if (goalReached()) {
-      vault.close();
+      escrow.close();
+      escrow.withdraw();
     } else {
-      vault.enableRefunds();
+      escrow.enableRefunds();
     }
 
     super.finalization();
   }
 
   /**
-   * @dev Overrides Crowdsale fund forwarding, sending funds to vault.
+   * @dev Overrides Crowdsale fund forwarding, sending funds to escrow.
    */
   function _forwardFunds() internal {
-    vault.deposit.value(msg.value)(msg.sender);
+    escrow.invest.value(msg.value)(msg.sender);
   }
 
 }

contracts/mocks/ConditionalEscrowMock.sol

@@ -0,0 +1,18 @@
+pragma solidity ^0.4.24;
+
+
+import "../payment/ConditionalEscrow.sol";
+
+
+// mock class using ConditionalEscrow
+contract ConditionalEscrowMock is ConditionalEscrow {
+  mapping(address => bool) public allowed;
+
+  function setAllowed(address _payee, bool _allowed) public {
+    allowed[_payee] = _allowed;
+  }
+
+  function withdrawalAllowed(address _payee) public view returns (bool) {
+    return allowed[_payee];
+  }
+}

contracts/payment/ConditionalEscrow.sol

@@ -0,0 +1,22 @@
+pragma solidity ^0.4.23;
+
+import "./Escrow.sol";
+
+
+/**
+ * @title ConditionalEscrow
+ * @dev Base abstract escrow to only allow withdrawal if a condition is met.
+ */
+contract ConditionalEscrow is Escrow {
+  /**
+  * @dev Returns whether an address is allowed to withdraw their funds. To be
+  * implemented by derived contracts.
+  * @param _payee The destination address of the funds.
+  */
+  function withdrawalAllowed(address _payee) public view returns (bool);
+
+  function withdraw(address _payee) public {
+    require(withdrawalAllowed(_payee));
+    super.withdraw(_payee);
+  }
+}

contracts/payment/Escrow.sol

@@ -0,0 +1,46 @@
+pragma solidity ^0.4.23;
+
+import "../math/SafeMath.sol";
+
+
+/**
+ * @title Escrow
+ * @dev Base escrow contract, holds funds destinated to a payee until they
+ * withdraw them.
+ */
+contract Escrow {
+  using SafeMath for uint256;
+
+  mapping(address => uint256) private deposits;
+
+  function depositsOf(address _payee) public view returns (uint256) {
+    return deposits[_payee];
+  }
+
+  /**
+  * @dev Called by the payer to store the sent amount as credit to be pulled.
+  * @param _payee The destination address of the funds.
+  */
+  function deposit(address _payee) payable public {
+    uint256 amount = msg.value;
+    require(amount > 0);
+
+    deposits[_payee] = deposits[_payee].add(amount);
+  }
+
+  /**
+  * @dev Withdraw accumulated balance for a payee. Any address can trigger a
+  * withdrawal.
+  * @param _payee The address whose funds will be withdrawn and transferred to.
+  */
+  function withdraw(address _payee) public {
+    uint256 payment = deposits[_payee];
+
+    require(payment != 0);
+    require(address(this).balance >= payment);
+
+    deposits[_payee] = 0;
+
+    _payee.transfer(payment);
+  }
+}

contracts/payment/PullPayment.sol

@@ -1,7 +1,6 @@
 pragma solidity ^0.4.24;
 
-
-import "../math/SafeMath.sol";
+import "./Escrow.sol";
 
 
 /**
@@ -10,34 +9,34 @@ import "../math/SafeMath.sol";
  * contract and use asyncSend instead of send or transfer.
  */
 contract PullPayment {
-  using SafeMath for uint256;
+  Escrow public escrow;
 
-  mapping(address => uint256) public payments;
-  uint256 public totalPayments;
+  constructor() public {
+    escrow = new Escrow();
+  }
 
   /**
   * @dev Withdraw accumulated balance, called by payee.
   */
   function withdrawPayments() public {
     address payee = msg.sender;
-    uint256 payment = payments[payee];
-
-    require(payment != 0);
-    require(address(this).balance >= payment);
-
-    totalPayments = totalPayments.sub(payment);
-    payments[payee] = 0;
+    escrow.withdraw(payee);
+  }
 
-    payee.transfer(payment);
+  /**
+  * @dev Returns the credit owed to an address.
+  & @param _dest The creditor's address.
+  */
+  function payments(address _dest) public view returns (uint256) {
+    return escrow.depositsOf(_dest);
   }
 
   /**
   * @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.
+  * @param _dest The destination address of the funds.
+  * @param _amount The amount to transfer.
   */
-  function asyncSend(address dest, uint256 amount) internal {
-    payments[dest] = payments[dest].add(amount);
-    totalPayments = totalPayments.add(amount);
+  function asyncSend(address _dest, uint256 _amount) internal {
+    escrow.deposit.value(_amount)(_dest);
   }
 }

contracts/payment/RefundEscrow.sol

@@ -0,0 +1,91 @@
+pragma solidity ^0.4.23;
+
+import "./ConditionalEscrow.sol";
+import "../ownership/Ownable.sol";
+
+
+/**
+ * @title RefundEscrow
+ * @dev Escrow that holds investor funds for a unique benefitiary, and allows for
+ * either withdrawal by the benefiatiary, or refunds to the investors.
+ */
+contract RefundEscrow is ConditionalEscrow, Ownable {
+  enum State { Active, Refunding, Closed }
+
+  event Closed();
+  event RefundsEnabled();
+  event Refunded(address indexed investor, uint256 weiAmount);
+
+  State public state;
+  address public beneficiary;
+
+  /**
+   * @dev Constructor.
+   * @param _beneficiary The beneficiary of the investments.
+   */
+  constructor(address _beneficiary) public {
+    require(_beneficiary != address(0));
+    beneficiary = _beneficiary;
+    state = State.Active;
+  }
+
+  /**
+   * @dev Stores funds that may later be refunded.
+   * @param _investor The address funds will be sent to if a refund occurs.
+   */
+  function invest(address _investor) payable public {
+    require(state == State.Active);
+    super.deposit(_investor);
+  }
+
+  /**
+   * @dev Disable the base deposit function, use invest instead.
+   */
+  function deposit(address _payee) payable public {
+    revert();
+  }
+
+  /**
+   * @dev Allows for the beneficiary to withdraw their funds, rejecting
+   * further investments.
+   */
+  function close() onlyOwner public {
+    require(state == State.Active);
+    state = State.Closed;
+    emit Closed();
+  }
+
+  /**
+   * @dev Allows for refunds to take place, rejecting further investments.
+   */
+  function enableRefunds() onlyOwner public {
+    require(state == State.Active);
+    state = State.Refunding;
+    emit RefundsEnabled();
+  }
+
+  /**
+   * @dev Withdraws the beneficiary's funds.
+   */
+  function withdraw() public {
+    require(state == State.Closed);
+    beneficiary.transfer(address(this).balance);
+  }
+
+  /**
+   * @dev Refunds an investor.
+   * @param _investor The address to refund.
+   */
+  function refund(address _investor) public {
+    uint256 amount = depositsOf(_investor);
+    super.withdraw(_investor);
+    emit Refunded(_investor, amount);
+  }
+
+  /**
+   * @dev Returns whether investors can withdraw their investments (be refunded).
+   */
+  function withdrawalAllowed(address _payee) public view returns (bool) {
+    return state == State.Refunding;
+  }
+}