[Proposal] 17: User Defined Coupon Expiry w/ FPSBA

protocol/contracts/dao/Auction.sol

@@ -0,0 +1,121 @@
+/*
+    Copyright 2020 Empty Set Squad <[email protected]>
+
+    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.5.17;
+pragma experimental ABIEncoderV2;
+
+import "@openzeppelin/contracts/math/SafeMath.sol";
+import "./Comptroller.sol";
+import "../Constants.sol";
+import "../external/Decimal.sol";
+
+contract Auction is Comptroller {
+    using SafeMath for uint256;
+    using Decimal for Decimal.D256;
+
+    Epoch.CouponBidderState[] private bids;
+
+    event AuctionCouponPurchase(address indexed account, uint256 indexed epoch, uint256 dollarAmount, uint256 couponAmount);
+
+    function sortBidsByDistance(Epoch.CouponBidderState[] memory bids) internal returns(Epoch.CouponBidderState[] memory) {
+       quickSort(bids, uint256(0), uint256(bids.length - 1));
+       return bids;
+    }
+
+    function quickSort(Epoch.CouponBidderState[] memory arr, uint256 left, uint256 right) internal {
+        uint256 i = left;
+        uint256 j = right;
+        if(i==j) return;
+        uint256 pivot = arr[uint256(left + (right - left) / 2)].distance;
+        while (i <= j) {
+            while (arr[uint256(i)].distance < pivot) i++;
+            while (pivot < arr[uint256(j)].distance) j--;
+            if (i <= j) {
+                (arr[uint256(i)], arr[uint256(j)]) = (arr[uint256(j)], arr[uint256(i)]);
+                i++;
+                j--;
+            }
+        }
+        if (left < j)
+            quickSort(arr, left, j);
+        if (i < right)
+            quickSort(arr, i, right);
+    }
+
+    function sqrt(uint256 x) internal pure returns (uint256 y) {
+        uint256 z = x.add(1).div(2);
+        y = x;
+        while (z < y) {
+            y = z;
+            z = x.div(z.add(z)).div(2);
+        }
+    }
+
+    function settleCouponAuction() public returns (bool success) {
+        if (!isCouponAuctionFinished() && !isCouponAuctionCanceled()) {
+
+            uint256 minMaturity = getCouponAuctionMinMaturity();
+            uint256 maxMaturity = getCouponAuctionMaxMaturity();
+            uint256 minYield = getCouponAuctionMinYield();
+            uint256 maxYield = getCouponAuctionMaxYield();            
+
+            // loop over bids and compute distance
+            for (uint256 i = 0; i < getCouponAuctionBids(); i++) {
+                uint256 couponMaturityEpoch = getCouponBidderState(getCouponBidderStateIndex(i)).couponMaturityEpoch;
+                uint256 couponAmount = getCouponBidderState(getCouponBidderStateIndex(i)).couponAmount;
+                uint256 dollarAmount = getCouponBidderState(getCouponBidderStateIndex(i)).dollarAmount;
+
+                uint256 yieldRel = couponAmount.div(
+                    dollarAmount
+                ).div(
+                    maxYield.sub(minYield)
+                );
+                uint256 maturityRel = couponMaturityEpoch.div(
+                    maxMaturity.sub(minMaturity)
+                );
+
+                uint256 yieldRelSquared = Decimal.zero().add(yieldRel).pow(2).asUint256();
+                uint256 maturityRelSquared = Decimal.zero().add(maturityRel).pow(2).asUint256();
+
+                uint256 sumSquared = yieldRelSquared.add(maturityRelSquared);
+                uint256 distance = sqrt(sumSquared);
+                getCouponBidderState(getCouponBidderStateIndex(i)).distance = distance;
+                bids.push(getCouponBidderState(getCouponBidderStateIndex(i)));
+            }
+
+            // sort bids
+            sortBidsByDistance(bids);
+
+            // assign coupons until totalDebt filled, reject the rest
+            for (uint256 i = 0; i < bids.length; i++) {
+                if (totalDebt() >= bids[i].dollarAmount) {
+                    if (!getCouponBidderStateRejected(bids[i].bidder) && !getCouponBidderStateRejected(bids[i].bidder)) {
+                        uint256 epoch = epoch().add(bids[i].couponMaturityEpoch);
+                        burnFromAccount(bids[i].bidder, bids[i].dollarAmount);
+                        incrementBalanceOfCoupons(bids[i].bidder, epoch, bids[i].couponAmount);
+                        emit AuctionCouponPurchase(bids[i].bidder, epoch, bids[i].dollarAmount, bids[i].couponAmount);
+                        setCouponBidderStateSelected(bids[i].bidder);
+                    }
+                } else {
+                    setCouponBidderStateRejected(bids[i].bidder);
+                } 
+            }
+            return true;
+        } else {
+            return true;
+        }        
+    }
+}

protocol/contracts/dao/Getters.sol

@@ -191,6 +191,54 @@ contract Getters is State {
         return epoch <= Constants.getBootstrappingPeriod();
     }
 
+    function getCouponAuctionAtEpoch(uint256 epoch) internal view returns (Epoch.AuctionState storage) {
+        return _state.epochs[epoch].auction;
+    }
+
+    function getCouponAuctionBids() internal view returns (uint256) {
+        return _state.epochs[epoch()].auction._totalBids;
+    }
+
+    function getCouponBidderState(address bidder) internal view returns (Epoch.CouponBidderState storage) {
+        return _state.epochs[epoch()].auction.couponBidderState[bidder];
+    }
+
+    function getCouponBidderStateSelected(address bidder) internal view returns (bool) {
+        return _state.epochs[epoch()].auction.couponBidderState[bidder].selected;
+    }
+
+    function getCouponBidderStateRejected(address bidder) internal view returns (bool) {
+        return _state.epochs[epoch()].auction.couponBidderState[bidder].rejected;
+    }
+
+    function getCouponBidderStateIndex(uint256 index) internal view returns (address) {
+        return _state.epochs[epoch()].auction.couponBidder[index];
+    }
+
+    function isCouponAuctionFinished() internal view returns (bool){
+        return _state.epochs[epoch()].auction.finished;
+    }
+
+    function isCouponAuctionCanceled() internal view returns (bool){
+        return _state.epochs[epoch()].auction.canceled;
+    }
+
+    function getCouponAuctionMinMaturity() internal view returns (uint256) {
+        return _state.epochs[epoch()].auction.minMaturity;
+    }
+
+    function getCouponAuctionMaxMaturity() internal view returns (uint256) {
+        return _state.epochs[epoch()].auction.maxMaturity;
+    }
+
+    function getCouponAuctionMinYield() internal view returns (uint256) {
+        return _state.epochs[epoch()].auction.minYield;
+    }
+
+    function getCouponAuctionMaxYield() internal view returns (uint256) {
+        return _state.epochs[epoch()].auction.maxYield;
+    }
+
     /**
      * Governance
      */

protocol/contracts/dao/Market.sol

@@ -32,7 +32,7 @@ contract Market is Comptroller, Curve {
     event CouponRedemption(address indexed account, uint256 indexed epoch, uint256 couponAmount);
     event CouponTransfer(address indexed from, address indexed to, uint256 indexed epoch, uint256 value);
     event CouponApproval(address indexed owner, address indexed spender, uint256 value);
-
+    
     function step() internal {
         // Expire prior coupons
         for (uint256 i = 0; i < expiringCoupons(epoch()); i++) {
@@ -117,4 +117,27 @@ contract Market is Comptroller, Curve {
 
         emit CouponTransfer(sender, recipient, epoch, amount);
     }
+
+    function placeCouponAuctionBid(uint256 couponEpochExpiry, uint256 dollarAmount, uint256 maxCouponAmount) external returns (bool success) {        
+        // reject coupon amounts of 0
+        Require.that(
+            maxCouponAmount > 0,
+            FILE,
+            "Your coupon amount is too low"
+        );
+
+        // reject payments of 0
+        Require.that(
+            dollarAmount > 0,
+            FILE,
+            "Your price is too low"
+        );
+
+        setCouponAuctionRelYield(maxCouponAmount.div(dollarAmount));
+        setCouponAuctionRelMaturity(couponEpochExpiry);
+        setCouponBidderState(msg.sender, couponEpochExpiry, dollarAmount, maxCouponAmount);
+        setCouponBidderStateIndex(getCouponAuctionBids(), msg.sender);
+        incrementCouponAuctionBids();
+        return true;
+    }
 }

protocol/contracts/dao/Regulator.sol

@@ -19,6 +19,7 @@ pragma experimental ABIEncoderV2;
 
 import "@openzeppelin/contracts/math/SafeMath.sol";
 import "./Comptroller.sol";
+import "./Auction.sol";
 import "../external/Decimal.sol";
 import "../Constants.sol";
 
@@ -34,11 +35,29 @@ contract Regulator is Comptroller {
         Decimal.D256 memory price = oracleCapture();
 
         if (price.greaterThan(Decimal.one())) {
+            Epoch.AuctionState storage auction = getCouponAuctionAtEpoch(epoch());
+
+            //check for outstanding auction, if exists cancel it
+            if (auction.couponAuction != address(0)){
+                cancelCouponAuctionAtEpoch(epoch());
+            }
+
             growSupply(price);
             return;
         }
 
         if (price.lessThan(Decimal.one())) {
+            Epoch.AuctionState storage auction = getCouponAuctionAtEpoch(epoch());
+
+            //check for outstanding auction, if exists settle it and start a new one
+            if (auction.couponAuction != address(0)){
+                Auction currentCouponAuction = Auction(auction.couponAuction);
+                bool isAuctionSettled = currentCouponAuction.settleCouponAuction();
+                finishCouponAuctionAtEpoch(epoch());
+            }
+            Auction newCouponAuction = new Auction();
+            initCouponAuction(address(newCouponAuction));
+
             shrinkSupply(price);
             return;
         }

protocol/contracts/dao/Setters.sol

@@ -149,6 +149,64 @@ contract Setters is State, Getters {
         _state.epochs[epoch].coupons.outstanding = 0;
     }
 
+    function initCouponAuction(address auction) internal  {
+        _state.epochs[epoch()].auction.couponAuction = auction;
+        _state.epochs[epoch()].auction._totalBids = 0;
+        _state.epochs[epoch()].auction.minMaturity = 1000000000000000000000000;
+        _state.epochs[epoch()].auction.maxMaturity = 0;
+        _state.epochs[epoch()].auction.minYield = 1000000000000000000000000;
+        _state.epochs[epoch()].auction.maxYield = 0;
+    }
+
+    function cancelCouponAuctionAtEpoch(uint256 epoch) internal {
+        _state.epochs[epoch].auction.canceled = true;
+    }
+
+    function finishCouponAuctionAtEpoch(uint256 epoch) internal {
+         _state.epochs[epoch].auction.finished = true;
+    }
+
+    function setCouponBidderState(address bidder, uint256 couponEpochExpiry, uint256 dollarAmount, uint256 maxCouponAmount) internal {
+        Epoch.CouponBidderState storage bidderState = _state.epochs[epoch()].auction.couponBidderState[bidder];
+
+        bidderState.couponMaturityEpoch = couponEpochExpiry;
+        bidderState.dollarAmount = dollarAmount;
+        bidderState.couponAmount = maxCouponAmount;
+        bidderState.bidder = bidder;
+    }
+
+    function setCouponBidderStateSelected(address bidder) internal {
+        _state.epochs[epoch()].auction.couponBidderState[bidder].selected = true;
+    }
+
+    function setCouponBidderStateRejected(address bidder) internal {
+        _state.epochs[epoch()].auction.couponBidderState[bidder].rejected = true;
+    }
+
+    function setCouponBidderStateIndex(uint256 index, address bidder) internal {
+        _state.epochs[epoch()].auction.couponBidder[index] = bidder;
+    }
+
+    function incrementCouponAuctionBids() internal {
+        _state.epochs[epoch()].auction._totalBids++;
+    }
+
+    function setCouponAuctionRelYield(uint256 yield) internal {
+        if (yield > _state.epochs[epoch()].auction.maxYield) {
+            _state.epochs[epoch()].auction.maxYield = yield;
+        } else if (yield < _state.epochs[epoch()].auction.minYield) {
+            _state.epochs[epoch()].auction.minYield = yield;
+        }
+    }
+    function setCouponAuctionRelMaturity(uint256 couponEpochExpiry) internal {
+        if (couponEpochExpiry > _state.epochs[epoch()].auction.maxMaturity) {
+            _state.epochs[epoch()].auction.maxMaturity = couponEpochExpiry;
+        } else if (couponEpochExpiry < _state.epochs[epoch()].auction.minMaturity) {
+            _state.epochs[epoch()].auction.minMaturity = couponEpochExpiry;
+        }
+    }
+
+
     /**
      * Governance
      */

protocol/contracts/dao/State.sol

@@ -52,10 +52,34 @@ contract Epoch {
         uint256[] expiring;
     }
 
+    struct CouponBidderState {
+        uint256 couponMaturityEpoch;
+        uint256 dollarAmount;
+        uint256 couponAmount;
+        uint256 distance;
+        address bidder;
+        bool selected;
+        bool rejected;
+    }
+
+    struct AuctionState {
+        bool canceled;
+        bool finished;
+        uint256 minMaturity;
+        uint256 maxMaturity;
+        uint256 minYield;
+        uint256 maxYield;
+        uint256 _totalBids;
+        mapping(uint256 => address) couponBidder;
+        mapping(address => CouponBidderState) couponBidderState;
+        address couponAuction;
+    }
+
     struct State {
         uint256 bonded;
         Coupons coupons;
-    }
+        AuctionState auction;
+    }    
 }
 
 contract Candidate {