Single price

CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+# 3.1.0 - Unreleased
+
+### Upgrade Steps -- Required
+
+Upgrade `BackingManager`, `Broker`, and _all_ assets
+
+Then call `Broker.cacheComponents()`.
+
+### Core Protocol Contracts
+
+- `BackingManager`
+  - Replace use of `lotPrice()` with `price()`
+- `Broker` [+1 slot]
+  - Disallow starting dutch trades with non-RTokenAsset assets when `lastSave() != block.timestamp`
+
+## Plugins
+
+### Assets
+
+- Remove `lotPrice()`
+- Alter `price().high` to decay upwards to 3x over the price timeout
+
 # 3.0.0 - Unreleased
 
 ### Upgrade Steps

contracts/facade/FacadeAct.sol

@@ -113,11 +113,11 @@ contract FacadeAct is IFacadeAct, Multicall {
             }
 
             surpluses[i] = erc20s[i].balanceOf(address(revenueTrader));
-            (uint192 lotLow, ) = reg.assets[i].lotPrice(); // {UoA/tok}
-            if (lotLow == 0) continue;
+            (uint192 low, ) = reg.assets[i].price(); // {UoA/tok}
+            if (low == 0) continue;
 
             // {qTok} = {UoA} / {UoA/tok}
-            minTradeAmounts[i] = minTradeVolume.safeDiv(lotLow, FLOOR).shiftl_toUint(
+            minTradeAmounts[i] = minTradeVolume.safeDiv(low, FLOOR).shiftl_toUint(
                 int8(reg.assets[i].erc20Decimals())
             );
 

contracts/interfaces/IAsset.sol

@@ -27,16 +27,11 @@ interface IAsset is IRewardable {
     function refresh() external;
 
     /// Should not revert
+    /// low should be nonzero if the asset could be worth selling
     /// @return low {UoA/tok} The lower end of the price estimate
     /// @return high {UoA/tok} The upper end of the price estimate
     function price() external view returns (uint192 low, uint192 high);
 
-    /// Should not revert
-    /// lotLow should be nonzero when the asset might be worth selling
-    /// @return lotLow {UoA/tok} The lower end of the lot price estimate
-    /// @return lotHigh {UoA/tok} The upper end of the lot price estimate
-    function lotPrice() external view returns (uint192 lotLow, uint192 lotHigh);
-
     /// @return {tok} The balance of the ERC20 in whole tokens
     function bal(address account) external view returns (uint192);
 
@@ -67,8 +62,14 @@ interface TestIAsset is IAsset {
     /// @return {s} Seconds that an oracle value is considered valid
     function oracleTimeout() external view returns (uint48);
 
-    /// @return {s} Seconds that the lotPrice should decay over, after stale price
+    /// @return {s} Seconds that the price().low should decay over, after stale price
     function priceTimeout() external view returns (uint48);
+
+    /// @return {UoA/tok} The last saved low price
+    function savedLowPrice() external view returns (uint192);
+
+    /// @return {UoA/tok} The last saved high price
+    function savedHighPrice() external view returns (uint192);
 }
 
 /// CollateralStatus must obey a linear ordering. That is:

contracts/interfaces/IBasketHandler.sol

@@ -133,16 +133,11 @@ interface IBasketHandler is IComponent {
     function basketsHeldBy(address account) external view returns (BasketRange memory);
 
     /// Should not revert
+    /// low should be nonzero when BUs are worth selling
     /// @return low {UoA/BU} The lower end of the price estimate
     /// @return high {UoA/BU} The upper end of the price estimate
     function price() external view returns (uint192 low, uint192 high);
 
-    /// Should not revert
-    /// lotLow should be nonzero if a BU could be worth selling
-    /// @return lotLow {UoA/tok} The lower end of the lot price estimate
-    /// @return lotHigh {UoA/tok} The upper end of the lot price estimate
-    function lotPrice() external view returns (uint192 lotLow, uint192 lotHigh);
-
     /// @return timestamp The timestamp at which the basket was last set
     function timestamp() external view returns (uint48);
 

contracts/interfaces/IBroker.sol

@@ -11,7 +11,7 @@ enum TradeKind {
     BATCH_AUCTION
 }
 
-/// Cache of all (lot) prices for a pair to prevent re-lookup
+/// Cache of all prices for a pair to prevent re-lookup
 struct TradePrices {
     uint192 sellLow; // {UoA/sellTok} can be 0
     uint192 sellHigh; // {UoA/sellTok} should not be 0

contracts/p0/BasketHandler.sol

@@ -368,26 +368,11 @@ contract BasketHandlerP0 is ComponentP0, IBasketHandler {
     }
 
     /// Should not revert
+    /// low should be nonzero when the asset might be worth selling
     /// @return low {UoA/BU} The lower end of the price estimate
     /// @return high {UoA/BU} The upper end of the price estimate
     // returns sum(quantity(erc20) * price(erc20) for erc20 in basket.erc20s)
     function price() external view returns (uint192 low, uint192 high) {
-        return _price(false);
-    }
-
-    /// Should not revert
-    /// lowLow should be nonzero when the asset might be worth selling
-    /// @return lotLow {UoA/BU} The lower end of the lot price estimate
-    /// @return lotHigh {UoA/BU} The upper end of the lot price estimate
-    // returns sum(quantity(erc20) * lotPrice(erc20) for erc20 in basket.erc20s)
-    function lotPrice() external view returns (uint192 lotLow, uint192 lotHigh) {
-        return _price(true);
-    }
-
-    /// Returns the price of a BU, using the lot prices if `useLotPrice` is true
-    /// @return low {UoA/BU} The lower end of the lot price estimate
-    /// @return high {UoA/BU} The upper end of the lot price estimate
-    function _price(bool useLotPrice) internal view returns (uint192 low, uint192 high) {
         IAssetRegistry reg = main.assetRegistry();
 
         uint256 low256;
@@ -397,9 +382,7 @@ contract BasketHandlerP0 is ComponentP0, IBasketHandler {
             uint192 qty = quantity(basket.erc20s[i]);
             if (qty == 0) continue;
 
-            (uint192 lowP, uint192 highP) = useLotPrice
-                ? reg.toAsset(basket.erc20s[i]).lotPrice()
-                : reg.toAsset(basket.erc20s[i]).price();
+            (uint192 lowP, uint192 highP) = reg.toAsset(basket.erc20s[i]).price();
 
             low256 += qty.safeMul(lowP, RoundingMode.FLOOR);
 

contracts/p0/Broker.sol

@@ -224,6 +224,11 @@ contract BrokerP0 is ComponentP0, IBroker {
             "dutch auctions disabled for token pair"
         );
         require(dutchAuctionLength > 0, "dutch auctions not enabled");
+        require(
+            priceIsCurrent(req.sell) && priceIsCurrent(req.buy),
+            "dutch auctions require live prices"
+        );
+
         DutchTrade trade = DutchTrade(Clones.clone(address(dutchTradeImplementation)));
         trades[address(trade)] = true;
 
@@ -248,4 +253,10 @@ contract BrokerP0 is ComponentP0, IBroker {
         emit DutchTradeDisabledSet(erc20, dutchTradeDisabled[erc20], disabled);
         dutchTradeDisabled[erc20] = disabled;
     }
+
+    /// @return true if the price is current, or it's the RTokenAsset
+    function priceIsCurrent(IAsset asset) private view returns (bool) {
+        return
+            asset.lastSave() == block.timestamp || address(asset.erc20()) == address(main.rToken());
+    }
 }

contracts/p0/RevenueTrader.sol

@@ -83,7 +83,7 @@ contract RevenueTraderP0 is TradingP0, IRevenueTrader {
         main.assetRegistry().refresh();
 
         IAsset assetToBuy = main.assetRegistry().toAsset(tokenToBuy);
-        (uint192 buyLow, uint192 buyHigh) = assetToBuy.lotPrice(); // {UoA/tok}
+        (uint192 buyLow, uint192 buyHigh) = assetToBuy.price(); // {UoA/tok}
         require(buyHigh > 0 && buyHigh < FIX_MAX, "buy asset price unknown");
 
         // For each ERC20: start auction of given kind
@@ -99,7 +99,7 @@ contract RevenueTraderP0 is TradingP0, IRevenueTrader {
             require(address(trades[erc20]) == address(0), "trade open");
             require(erc20.balanceOf(address(this)) > 0, "0 balance");
 
-            (uint192 sellLow, uint192 sellHigh) = assetToSell.lotPrice(); // {UoA/tok}
+            (uint192 sellLow, uint192 sellHigh) = assetToSell.price(); // {UoA/tok}
 
             TradingLibP0.TradeInfo memory trade = TradingLibP0.TradeInfo({
                 sell: assetToSell,

contracts/p0/mixins/TradingLib.sol

@@ -274,7 +274,7 @@ library TradingLibP0 {
         view
         returns (BasketRange memory range)
     {
-        (uint192 buPriceLow, uint192 buPriceHigh) = ctx.bh.lotPrice(); // {UoA/BU}
+        (uint192 buPriceLow, uint192 buPriceHigh) = ctx.bh.price(); // {UoA/BU}
 
         // Cap ctx.basketsHeld.top
         if (ctx.basketsHeld.top > ctx.rToken.basketsNeeded()) {
@@ -303,21 +303,14 @@ library TradingLibP0 {
                 bal = bal.plus(asset.bal(address(ctx.stRSR)));
             }
 
-            {
-                // Skip over dust-balance assets not in the basket
-                (uint192 lotLow, ) = asset.lotPrice(); // {UoA/tok}
-
-                // Intentionally include value of IFFY/DISABLED collateral
-                if (
-                    ctx.bh.quantity(erc20s[i]) == 0 &&
-                    !isEnoughToSell(asset, bal, lotLow, ctx.minTradeVolume)
-                ) continue;
-            }
-
             (uint192 low, uint192 high) = asset.price(); // {UoA/tok}
-            // price() is better than lotPrice() here: it's important to not underestimate how
-            // much value could be in a token that is unpriced by using a decaying high lotPrice.
-            // price() will return [0, FIX_MAX] in this case, which is preferable.
+
+            // Skip over dust-balance assets not in the basket
+            // Intentionally include value of IFFY/DISABLED collateral
+            if (
+                ctx.bh.quantity(erc20s[i]) == 0 &&
+                !isEnoughToSell(asset, bal, low, ctx.minTradeVolume)
+            ) continue;
 
             // throughout these sections +/- is same as Fix.plus/Fix.minus and </> is Fix.gt/.lt
 
@@ -354,7 +347,7 @@ library TradingLibP0 {
 
                 // (2) Lose minTradeVolume to dust (why: auctions can return tokens)
                 // Q: Why is this precisely where we should take out minTradeVolume?
-                // A: Our use of isEnoughToSell always uses the low price (lotLow, technically),
+                // A: Our use of isEnoughToSell always uses the low price (low, technically),
                 //   so min trade volumes are always assesed based on low prices. At this point
                 //   in the calculation we have already calculated the UoA amount corresponding to
                 //   the excess token balance based on its low price, so we are already set up
@@ -453,19 +446,19 @@ library TradingLibP0 {
             // {tok} = {BU} * {tok/BU}
             uint192 needed = range.top.mul(ctx.bh.quantity(erc20s[i]), CEIL); // {tok}
             if (bal.gt(needed)) {
-                (uint192 lotLow, uint192 lotHigh) = asset.lotPrice(); // {UoA/sellTok}
-                if (lotHigh == 0) continue; // Skip worthless assets
+                (uint192 low, uint192 high) = asset.price(); // {UoA/sellTok}
+                if (high == 0) continue; // Skip worthless assets
 
                 // by calculating this early we can duck the stack limit but be less gas-efficient
                 bool enoughToSell = isEnoughToSell(
                     asset,
                     bal.minus(needed),
-                    lotLow,
+                    low,
                     ctx.minTradeVolume
                 );
 
                 // {UoA} = {sellTok} * {UoA/sellTok}
-                uint192 delta = bal.minus(needed).mul(lotLow, FLOOR);
+                uint192 delta = bal.minus(needed).mul(low, FLOOR);
 
                 // status = asset.status() if asset.isCollateral() else SOUND
                 CollateralStatus status; // starts SOUND
@@ -476,8 +469,8 @@ library TradingLibP0 {
                 if (isBetterSurplus(maxes, status, delta) && enoughToSell) {
                     trade.sell = asset;
                     trade.sellAmount = bal.minus(needed);
-                    trade.prices.sellLow = lotLow;
-                    trade.prices.sellHigh = lotHigh;
+                    trade.prices.sellLow = low;
+                    trade.prices.sellHigh = high;
 
                     maxes.surplusStatus = status;
                     maxes.surplus = delta;
@@ -487,17 +480,17 @@ library TradingLibP0 {
                 needed = range.bottom.mul(ctx.bh.quantity(erc20s[i]), CEIL); // {buyTok};
                 if (bal.lt(needed)) {
                     uint192 amtShort = needed.minus(bal); // {buyTok}
-                    (uint192 lotLow, uint192 lotHigh) = asset.lotPrice(); // {UoA/buyTok}
+                    (uint192 low, uint192 high) = asset.price(); // {UoA/buyTok}
 
                     // {UoA} = {buyTok} * {UoA/buyTok}
-                    uint192 delta = amtShort.mul(lotHigh, CEIL);
+                    uint192 delta = amtShort.mul(high, CEIL);
 
                     // The best asset to buy is whichever asset has the largest deficit
                     if (delta.gt(maxes.deficit)) {
                         trade.buy = ICollateral(address(asset));
                         trade.buyAmount = amtShort;
-                        trade.prices.buyLow = lotLow;
-                        trade.prices.buyHigh = lotHigh;
+                        trade.prices.buyLow = low;
+                        trade.prices.buyHigh = high;
 
                         maxes.deficit = delta;
                     }
@@ -512,13 +505,13 @@ library TradingLibP0 {
             uint192 rsrAvailable = rsrAsset.bal(address(ctx.bm)).plus(
                 rsrAsset.bal(address(ctx.stRSR))
             );
-            (uint192 lotLow, uint192 lotHigh) = rsrAsset.lotPrice(); // {UoA/RSR}
+            (uint192 low, uint192 high) = rsrAsset.price(); // {UoA/RSR}
 
-            if (lotHigh > 0 && isEnoughToSell(rsrAsset, rsrAvailable, lotLow, ctx.minTradeVolume)) {
+            if (high > 0 && isEnoughToSell(rsrAsset, rsrAvailable, low, ctx.minTradeVolume)) {
                 trade.sell = rsrAsset;
                 trade.sellAmount = rsrAvailable;
-                trade.prices.sellLow = lotLow;
-                trade.prices.sellHigh = lotHigh;
+                trade.prices.sellLow = low;
+                trade.prices.sellHigh = high;
             }
         }
     }

contracts/p1/BasketHandler.sol

@@ -309,27 +309,11 @@ contract BasketHandlerP1 is ComponentP1, IBasketHandler {
     }
 
     /// Should not revert
+    /// low should be nonzero when BUs are worth selling
     /// @return low {UoA/BU} The lower end of the price estimate
     /// @return high {UoA/BU} The upper end of the price estimate
     // returns sum(quantity(erc20) * price(erc20) for erc20 in basket.erc20s)
     function price() external view returns (uint192 low, uint192 high) {
-        return _price(false);
-    }
-
-    /// Should not revert
-    /// lowLow should be nonzero when the asset might be worth selling
-    /// @return lotLow {UoA/BU} The lower end of the lot price estimate
-    /// @return lotHigh {UoA/BU} The upper end of the lot price estimate
-    // returns sum(quantity(erc20) * lotPrice(erc20) for erc20 in basket.erc20s)
-    function lotPrice() external view returns (uint192 lotLow, uint192 lotHigh) {
-        return _price(true);
-    }
-
-    /// Returns the price of a BU, using the lot prices if `useLotPrice` is true
-    /// @param useLotPrice Whether to use lotPrice() or price()
-    /// @return low {UoA/BU} The lower end of the price estimate
-    /// @return high {UoA/BU} The upper end of the price estimate
-    function _price(bool useLotPrice) internal view returns (uint192 low, uint192 high) {
         uint256 low256;
         uint256 high256;
 
@@ -338,9 +322,7 @@ contract BasketHandlerP1 is ComponentP1, IBasketHandler {
             uint192 qty = quantity(basket.erc20s[i]);
             if (qty == 0) continue;
 
-            (uint192 lowP, uint192 highP) = useLotPrice
-                ? assetRegistry.toAsset(basket.erc20s[i]).lotPrice()
-                : assetRegistry.toAsset(basket.erc20s[i]).price();
+            (uint192 lowP, uint192 highP) = assetRegistry.toAsset(basket.erc20s[i]).price();
 
             low256 += qty.safeMul(lowP, RoundingMode.FLOOR);