Brian/require issue to start rebalance

contracts/core/tokens/RebalancingSetToken.sol

@@ -341,10 +341,21 @@ contract RebalancingSetToken is
     function endFailedAuction()
         external
     {
+        (
+            ,
+            uint256 calculatedUnitShares
+        ) = StandardSettleRebalanceLibrary.calculateNextSetIssueQuantity(
+            totalSupply(),
+            naturalUnit,
+            nextSet,
+            vault
+        );
+
         // Fail auction and either reset to Default state or kill Rebalancing Set Token and enter Drawdown
         // state
         uint8 integerRebalanceState = StandardFailAuctionLibrary.endFailedAuction(
             startingCurrentSetAmount,
+            calculatedUnitShares,
             currentSet,
             core,
             auctionParameters,

contracts/core/tokens/rebalancing-libraries/StandardFailAuctionLibrary.sol

@@ -42,6 +42,7 @@ library StandardFailAuctionLibrary {
      * if bids have been placed. Reset to Default state if no bids placed.
      *
      * @param _startingCurrentSetAmount     Amount of current set at beginning or rebalance
+     * @param _calculatedUnitShares         Calculated unitShares amount if rebalance were to be settled
      * @param _currentSet                   The Set that failed to rebalance
      * @param _coreAddress                  Core address
      * @param _auctionParameters            Struct containing auction price curve parameters
@@ -51,6 +52,7 @@ library StandardFailAuctionLibrary {
      */
     function endFailedAuction(
         uint256 _startingCurrentSetAmount,
+        uint256 _calculatedUnitShares,
         address _currentSet,
         address _coreAddress,
         RebalancingHelperLibrary.AuctionPriceParameters _auctionParameters,
@@ -77,30 +79,41 @@ library StandardFailAuctionLibrary {
             "RebalanceAuctionModule.endFailedAuction: Can only be called after auction reaches pivot"
         );
 
-        // If settleRebalance can be called than endFailedAuction can't be
-        require(
-            _biddingParameters.remainingCurrentSets >= _biddingParameters.minimumBid,
-            "RebalancingSetToken.endFailedAuction: Cannot be called if rebalance is completed"
-        );
-
-        // Declare rebalance state variable
-        RebalancingHelperLibrary.State _newRebalanceState;
-
-        // Check if any bids have been placed
-        if (_startingCurrentSetAmount == _biddingParameters.remainingCurrentSets) {
-            // If bid not placed, reissue current Set
-            ICore(_coreAddress).issueInVault(
-                _currentSet,
-                _startingCurrentSetAmount
-            );
-
-            // Set Rebalance Set Token state to Default
-            _newRebalanceState = RebalancingHelperLibrary.State.Default;
+        uint8 newRebalanceState;
+        /**
+         * If not enough sets have been bid on then allow auction to fail where no bids being registered
+         * returns the rebalancing set token to pre-auction state and some bids being registered puts the
+         * rebalancing set token in Drawdown mode.
+         * 
+         * However, if enough sets have been bid on. Then allow auction to fail and enter Drawdown state if
+         * and only if the calculated post-auction unitShares is equal to 0.
+         */
+        if (_biddingParameters.remainingCurrentSets >= _biddingParameters.minimumBid) {
+            // Check if any bids have been placed
+            if (_startingCurrentSetAmount == _biddingParameters.remainingCurrentSets) {
+                // If bid not placed, reissue current Set
+                ICore(_coreAddress).issueInVault(
+                    _currentSet,
+                    _startingCurrentSetAmount
+                );
+
+                // Set Rebalance Set Token state to Default
+                newRebalanceState = uint8(RebalancingHelperLibrary.State.Default);
+            } else {
+                // Set Rebalancing Set Token to Drawdown state
+                newRebalanceState = uint8(RebalancingHelperLibrary.State.Drawdown);
+            }
         } else {
-            // Set Rebalancing Set Token to Drawdown state
-            _newRebalanceState = RebalancingHelperLibrary.State.Drawdown;
+            // If settleRebalance can be called then endFailedAuction can't be
+            require(
+                _calculatedUnitShares == 0,
+                "RebalancingSetToken.endFailedAuction: Cannot be called if rebalance is viably completed"
+            ); 
+
+            // If calculated unitShares equals 0 set to Drawdown state
+            newRebalanceState = uint8(RebalancingHelperLibrary.State.Drawdown);
         }
 
-        return uint8(_newRebalanceState);
+        return newRebalanceState;
     }
 }

contracts/core/tokens/rebalancing-libraries/StandardSettleRebalanceLibrary.sol

@@ -97,6 +97,11 @@ library StandardSettleRebalanceLibrary {
             _vaultAddress
         );
 
+        require(
+            nextUnitShares > 0,
+            "RebalancingSetToken.settleRebalance: Failed rebalance, unitshares equals 0. Call endFailedAuction."
+        );
+
         // Issue nextSet to RebalancingSetToken
         ICore(_coreAddress).issueInVault(
             _nextSet,
@@ -132,7 +137,7 @@ library StandardSettleRebalanceLibrary {
             _vaultAddress,
             setDetails
         );
-
+        
         // Calculate the amount of naturalUnits worth of rebalancingSetToken outstanding
         uint256 naturalUnitsOutstanding = _totalSupply.div(_naturalUnit);
 
@@ -201,6 +206,6 @@ library StandardSettleRebalanceLibrary {
             }
         }
 
-        return maxIssueAmount;       
+        return maxIssueAmount; 
     }
 }

contracts/core/tokens/rebalancing-libraries/StandardStartRebalanceLibrary.sol

@@ -88,13 +88,13 @@ library StandardStartRebalanceLibrary {
         // Must be in "Proposal" state before going into "Rebalance" state
         require(
             _rebalanceState == uint8(RebalancingHelperLibrary.State.Proposal),
-            "RebalancingSetToken.rebalance: State must be Proposal"
+            "RebalancingSetToken.startRebalance: State must be Proposal"
         );
 
         // Be sure the full proposal period has elapsed
         require(
             block.timestamp >= _proposalStartTime.add(_proposalPeriod),
-            "RebalancingSetToken.rebalance: Proposal period not elapsed"
+            "RebalancingSetToken.startRebalance: Proposal period not elapsed"
         );
 
         // Create combined array data structures and calculate minimum bid needed for auction
@@ -111,6 +111,13 @@ library StandardStartRebalanceLibrary {
             _vaultAddress
         );
 
+        // Require remainingCurrentSets to be greater than minimumBid otherwise no bidding would
+        // be allowed
+        require(
+            biddingParameters.remainingCurrentSets >= biddingParameters.minimumBid,
+            "RebalancingSetToken.startRebalance: Not enough collateral to rebalance"
+        );
+
         return biddingParameters;
     }
 

contracts/mocks/core/lib/UpdatableConstantAuctionPriceCurve.sol

@@ -0,0 +1,58 @@
+/*
+    Copyright 2018 Set Labs Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+pragma solidity 0.4.25;
+pragma experimental "ABIEncoderV2";
+
+import { SafeMath } from "openzeppelin-solidity/contracts/math/SafeMath.sol";
+import { ConstantAuctionPriceCurve } from "./ConstantAuctionPriceCurve.sol";
+import { RebalancingHelperLibrary } from "../../../core/lib/RebalancingHelperLibrary.sol";
+
+/**
+ * @title UpdatableConstantAuctionPriceCurve
+ * @author Set Protocol
+ *
+ * Contract used in rebalancing auction testing to return consistent price.
+ * !!!!!!!!!!!!! DO NOT DEPLOY !!!!!!!!!!!!!
+ *
+ */
+
+contract UpdatableConstantAuctionPriceCurve is ConstantAuctionPriceCurve {
+
+    constructor(
+        uint256 _priceNumerator,
+        uint256 _priceDenominator
+    )
+        public
+        ConstantAuctionPriceCurve(
+            _priceNumerator,
+            _priceDenominator
+        )
+    {}
+
+    /*
+     * Update constant auction price
+     *
+     * @param _newPrice  Price to update to
+     */
+    function updatePrice(
+        uint256 _newPrice
+    )
+        public
+    {
+        priceNumerator = _newPrice;
+    }
+}

test/contracts/core/modules/rebalanceAuctionModule.spec.ts

@@ -551,6 +551,13 @@ contract('RebalanceAuctionModule', accounts => {
 
     describe('when getBidPrice is called from Rebalance State', async () => {
       beforeEach(async () => {
+        // Issue currentSetToken
+        await coreMock.issue.sendTransactionAsync(currentSetToken.address, ether(9), {from: deployerAccount});
+        await erc20Wrapper.approveTransfersAsync([currentSetToken], transferProxy.address);
+
+        // Use issued currentSetToken to issue rebalancingSetToken
+        await coreMock.issue.sendTransactionAsync(rebalancingSetToken.address, ether(7));
+
         await rebalancingWrapper.defaultTransitionToRebalanceAsync(
           coreMock,
           rebalancingComponentWhiteList,
@@ -762,6 +769,13 @@ contract('RebalanceAuctionModule', accounts => {
 
     describe('when placeBid is called from Rebalance State', async () => {
       beforeEach(async () => {
+        // Issue currentSetToken
+        await coreMock.issue.sendTransactionAsync(currentSetToken.address, ether(9), {from: deployerAccount});
+        await erc20Wrapper.approveTransfersAsync([currentSetToken], transferProxy.address);
+
+        // Use issued currentSetToken to issue rebalancingSetToken
+        await coreMock.issue.sendTransactionAsync(rebalancingSetToken.address, ether(7));
+
         await rebalancingWrapper.defaultTransitionToRebalanceAsync(
           coreMock,
           rebalancingComponentWhiteList,