RefundableCrowdsale now uses a RefundEscrow, removed RefundVault.

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/payment/Escrow.sol

@@ -11,10 +11,10 @@ import "../math/SafeMath.sol";
 contract Escrow {
   using SafeMath for uint256;
 
-  mapping(address => uint256) private _deposits;
+  mapping(address => uint256) private deposits;
 
-  function deposits(address _payee) public view returns (uint256) {
-    return _deposits[_payee];
+  function depositsOf(address _payee) public view returns (uint256) {
+    return deposits[_payee];
   }
 
   /**
@@ -25,7 +25,7 @@ contract Escrow {
     uint256 amount = msg.value;
     require(amount > 0);
 
-    _deposits[_payee] = _deposits[_payee].add(amount);
+    deposits[_payee] = deposits[_payee].add(amount);
   }
 
   /**
@@ -34,12 +34,12 @@ contract Escrow {
   * @param _payee The address whose funds will be withdrawn and transferred to.
   */
   function withdraw(address _payee) public {
-    uint256 payment = _deposits[_payee];
+    uint256 payment = deposits[_payee];
 
     require(payment != 0);
     require(address(this).balance >= payment);
 
-    _deposits[_payee] = 0;
+    deposits[_payee] = 0;
 
     _payee.transfer(payment);
   }

contracts/payment/PullPayment.sol

@@ -28,7 +28,7 @@ contract PullPayment {
   & @param _dest The creditor's address.
   */
   function payments(address _dest) public view returns (uint256) {
-    return escrow.deposits(_dest);
+    return escrow.depositsOf(_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;
+  }
+}