Merge pull request #510 from AugurProject/universe_validation

Store valid universes and use to validate trading contracts and logs. Genesis universe creation from `Augur`

Author: nuevoalex

source/contracts/Augur.sol

@@ -2,6 +2,7 @@ pragma solidity 0.4.18;
 
 import 'Controlled.sol';
 import 'libraries/token/ERC20.sol';
+import 'factories/UniverseFactory.sol';
 import 'reporting/IUniverse.sol';
 import 'reporting/IMarket.sol';
 import 'reporting/IFeeWindow.sol';
@@ -34,6 +35,33 @@ contract Augur is Controlled, Extractable {
     event TokensBurned(address indexed universe, address indexed token, address indexed target, uint256 amount);
     event FeeWindowCreated(address indexed universe, address feeWindow, uint256 startTime, uint256 endTime, uint256 id);
 
+    mapping(address => bool) private universes;
+
+    //
+    // Universe
+    //
+
+    function createGenesisUniverse() public returns (IUniverse) {
+        return createUniverse(IUniverse(0), bytes32(0));
+    }
+
+    function createChildUniverse(bytes32 _parentPayoutDistributionHash) public returns (IUniverse) {
+        IUniverse _parentUniverse = IUniverse(msg.sender);
+        require(isKnownUniverse(_parentUniverse));
+        return createUniverse(_parentUniverse, _parentPayoutDistributionHash);
+    }
+
+    function createUniverse(IUniverse _parentUniverse, bytes32 _parentPayoutDistributionHash) private returns (IUniverse) {
+        UniverseFactory _universeFactory = UniverseFactory(controller.lookup("UniverseFactory"));
+        IUniverse _newUniverse = _universeFactory.createUniverse(controller, _parentUniverse, _parentPayoutDistributionHash);
+        universes[_newUniverse] = true;
+        return _newUniverse;
+    }
+
+    function isKnownUniverse(IUniverse _universe) public view returns (bool) {
+        return universes[_universe];
+    }
+
     //
     // Transfer
     //
@@ -50,49 +78,57 @@ contract Augur is Controlled, Extractable {
 
     // This signature is intended for the categorical market creation. We use two signatures for the same event because of stack depth issues which can be circumvented by maintaining order of paramaters
     function logMarketCreated(bytes32 _topic, string _description, string _extraInfo, IUniverse _universe, address _market, address _marketCreator, bytes32[] _outcomes, int256 _minPrice, int256 _maxPrice, IMarket.MarketType _marketType) public returns (bool) {
+        require(isKnownUniverse(_universe));
         require(_universe == IUniverse(msg.sender));
         MarketCreated(_topic, _description, _extraInfo, _universe, _market, _marketCreator, _outcomes, _universe.getOrCacheMarketCreationCost(), _minPrice, _maxPrice, _marketType);
         return true;
     }
 
     // This signature is intended for binary and scalar market creation. See function comment above for explanation.
     function logMarketCreated(bytes32 _topic, string _description, string _extraInfo, IUniverse _universe, address _market, address _marketCreator, int256 _minPrice, int256 _maxPrice, IMarket.MarketType _marketType) public returns (bool) {
+        require(isKnownUniverse(_universe));
         require(_universe == IUniverse(msg.sender));
         MarketCreated(_topic, _description, _extraInfo, _universe, _market, _marketCreator, new bytes32[](0), _universe.getOrCacheMarketCreationCost(), _minPrice, _maxPrice, _marketType);
         return true;
     }
 
     function logInitialReportSubmitted(IUniverse _universe, address _reporter, address _market, uint256 _amountStaked, bool _isDesignatedReporter, uint256[] _payoutNumerators) public returns (bool) {
+        require(isKnownUniverse(_universe));
         require(_universe.isContainerForMarket(IMarket(msg.sender)));
         InitialReportSubmitted(_universe, _reporter, _market, _amountStaked, _isDesignatedReporter, _payoutNumerators);
         return true;
     }
 
     function logDisputeCrowdsourcerCreated(IUniverse _universe, address _market, address _disputeCrowdsourcer, uint256[] _payoutNumerators, uint256 _size) public returns (bool) {
+        require(isKnownUniverse(_universe));
         require(_universe.isContainerForMarket(IMarket(msg.sender)));
         DisputeCrowdsourcerCreated(_universe, _market, _disputeCrowdsourcer, _payoutNumerators, _size);
         return true;
     }
 
     function logDisputeCrowdsourcerContribution(IUniverse _universe, address _reporter, address _market, address _disputeCrowdsourcer, uint256 _amountStaked) public returns (bool) {
+        require(isKnownUniverse(_universe));
         require(_universe.isContainerForMarket(IMarket(msg.sender)));
         DisputeCrowdsourcerContribution(_universe, _reporter, _market, _disputeCrowdsourcer, _amountStaked);
         return true;
     }
 
     function logDisputeCrowdsourcerCompleted(IUniverse _universe, address _market, address _disputeCrowdsourcer) public returns (bool) {
+        require(isKnownUniverse(_universe));
         require(_universe.isContainerForMarket(IMarket(msg.sender)));
         DisputeCrowdsourcerCompleted(_universe, _market, _disputeCrowdsourcer);
         return true;
     }
 
     function logWinningTokensRedeemed(IUniverse _universe, address _reporter, address _market, address _reportingParticipant, uint256 _amountRedeemed, uint256 _reportingFeesReceived, uint256[] _payoutNumerators) public returns (bool) {
+        require(isKnownUniverse(_universe));
         require(_universe.isContainerForReportingParticipant(IReportingParticipant(msg.sender)));
         WinningsRedeemed(_universe, _reporter, _market, _reportingParticipant, _amountRedeemed, _reportingFeesReceived, _payoutNumerators);
         return true;
     }
 
     function logMarketFinalized(IUniverse _universe, address _market) public returns (bool) {
+        require(isKnownUniverse(_universe));
         require(_universe.isContainerForMarket(IMarket(msg.sender)));
         MarketFinalized(_universe, _market);
         return true;
@@ -119,107 +155,125 @@ contract Augur is Controlled, Extractable {
     }
 
     function logUniverseForked() public returns (bool) {
+        require(universes[msg.sender]);
         UniverseForked(msg.sender);
         return true;
     }
 
     function logUniverseCreated(IUniverse _childUniverse) public returns (bool) {
+        require(universes[msg.sender]);
         IUniverse _parentUniverse = IUniverse(msg.sender);
         require(_parentUniverse.isParentOf(_childUniverse));
         UniverseCreated(_parentUniverse, _childUniverse);
         return true;
     }
 
     function logFeeWindowTransferred(IUniverse _universe, address _from, address _to, uint256 _value) public returns (bool) {
+        require(isKnownUniverse(_universe));
         require(_universe.isContainerForFeeWindow(IFeeWindow(msg.sender)));
         TokensTransferred(_universe, msg.sender, _from, _to, _value);
         return true;
     }
 
     function logReputationTokensTransferred(IUniverse _universe, address _from, address _to, uint256 _value) public returns (bool) {
+        require(isKnownUniverse(_universe));
         require(_universe.getReputationToken() == IReputationToken(msg.sender));
         TokensTransferred(_universe, msg.sender, _from, _to, _value);
         return true;
     }
 
     function logDisputeCrowdsourcerTokensTransferred(IUniverse _universe, address _from, address _to, uint256 _value) public returns (bool) {
+        require(isKnownUniverse(_universe));
         require(_universe.isContainerForReportingParticipant(IReportingParticipant(msg.sender)));
         TokensTransferred(_universe, msg.sender, _from, _to, _value);
         return true;
     }
 
     function logShareTokensTransferred(IUniverse _universe, address _from, address _to, uint256 _value) public returns (bool) {
+        require(isKnownUniverse(_universe));
         require(_universe.isContainerForShareToken(IShareToken(msg.sender)));
         TokensTransferred(_universe, msg.sender, _from, _to, _value);
         return true;
     }
 
     function logReputationTokenBurned(IUniverse _universe, address _target, uint256 _amount) public returns (bool) {
+        require(isKnownUniverse(_universe));
         require(_universe.getReputationToken() == IReputationToken(msg.sender));
         TokensBurned(_universe, msg.sender, _target, _amount);
         return true;
     }
 
     function logReputationTokenMinted(IUniverse _universe, address _target, uint256 _amount) public returns (bool) {
+        require(isKnownUniverse(_universe));
         require(_universe.getReputationToken() == IReputationToken(msg.sender));
         TokensMinted(_universe, msg.sender, _target, _amount);
         return true;
     }
 
     function logShareTokenBurned(IUniverse _universe, address _target, uint256 _amount) public returns (bool) {
+        require(isKnownUniverse(_universe));
         require(_universe.isContainerForShareToken(IShareToken(msg.sender)));
         TokensBurned(_universe, msg.sender, _target, _amount);
         return true;
     }
 
     function logShareTokenMinted(IUniverse _universe, address _target, uint256 _amount) public returns (bool) {
+        require(isKnownUniverse(_universe));
         require(_universe.isContainerForShareToken(IShareToken(msg.sender)));
         TokensMinted(_universe, msg.sender, _target, _amount);
         return true;
     }
 
     function logFeeWindowBurned(IUniverse _universe, address _target, uint256 _amount) public returns (bool) {
+        require(isKnownUniverse(_universe));
         require(_universe.isContainerForFeeWindow(IFeeWindow(msg.sender)));
         TokensBurned(_universe, msg.sender, _target, _amount);
         return true;
     }
 
     function logFeeWindowMinted(IUniverse _universe, address _target, uint256 _amount) public returns (bool) {
+        require(isKnownUniverse(_universe));
         require(_universe.isContainerForFeeWindow(IFeeWindow(msg.sender)));
         TokensMinted(_universe, msg.sender, _target, _amount);
         return true;
     }
 
     function logDisputeCrowdsourcerTokensBurned(IUniverse _universe, address _target, uint256 _amount) public returns (bool) {
+        require(isKnownUniverse(_universe));
         require(_universe.isContainerForReportingParticipant(IReportingParticipant(msg.sender)));
         TokensBurned(_universe, msg.sender, _target, _amount);
         return true;
     }
 
     function logDisputeCrowdsourcerTokensMinted(IUniverse _universe, address _target, uint256 _amount) public returns (bool) {
+        require(isKnownUniverse(_universe));
         require(_universe.isContainerForReportingParticipant(IReportingParticipant(msg.sender)));
         TokensMinted(_universe, msg.sender, _target, _amount);
         return true;
     }
 
     function logFeeWindowCreated(IFeeWindow _feeWindow, uint256 _id) public returns (bool) {
+        require(universes[msg.sender]);
         FeeWindowCreated(msg.sender, _feeWindow, _feeWindow.getStartTime(), _feeWindow.getEndTime(), _id);
         return true;
     }
 
     function logFeeTokenTransferred(IUniverse _universe, address _from, address _to, uint256 _value) public returns (bool) {
+        require(isKnownUniverse(_universe));
         require(_universe.isContainerForFeeToken(IFeeToken(msg.sender)));
         TokensTransferred(_universe, msg.sender, _from, _to, _value);
         return true;
     }
 
     function logFeeTokenBurned(IUniverse _universe, address _target, uint256 _amount) public returns (bool) {
+        require(isKnownUniverse(_universe));
         require(_universe.isContainerForFeeToken(IFeeToken(msg.sender)));
         TokensBurned(_universe, msg.sender, _target, _amount);
         return true;
     }
 
     function logFeeTokenMinted(IUniverse _universe, address _target, uint256 _amount) public returns (bool) {
+        require(isKnownUniverse(_universe));
         require(_universe.isContainerForFeeToken(IFeeToken(msg.sender)));
         TokensMinted(_universe, msg.sender, _target, _amount);
         return true;

source/contracts/libraries/MarketValidator.sol

@@ -0,0 +1,14 @@
+pragma solidity 0.4.18;
+
+import 'reporting/IMarket.sol';
+import 'Controlled.sol';
+
+
+contract MarketValidator is Controlled {
+    modifier marketIsLegit(IMarket _market) {
+        IUniverse _universe = _market.getUniverse();
+        require(controller.getAugur().isKnownUniverse(_universe));
+        require(_universe.isContainerForMarket(_market));
+        _;
+    }
+}

source/contracts/reporting/Universe.sol

@@ -8,7 +8,6 @@ import 'libraries/Initializable.sol';
 import 'factories/ReputationTokenFactory.sol';
 import 'factories/FeeWindowFactory.sol';
 import 'factories/MarketFactory.sol';
-import 'factories/UniverseFactory.sol';
 import 'reporting/IMarket.sol';
 import 'reporting/IReputationToken.sol';
 import 'reporting/IFeeWindow.sol';
@@ -171,7 +170,7 @@ contract Universe is DelegationTarget, Extractable, ITyped, Initializable, IUniv
         require(_reportingParticipant.getMarket() == forkingMarket);
         IUniverse _childUniverse = getChildUniverse(_parentPayoutDistributionHash);
         if (_childUniverse == IUniverse(0)) {
-            _childUniverse = UniverseFactory(controller.lookup("UniverseFactory")).createUniverse(controller, this, _parentPayoutDistributionHash);
+            _childUniverse = controller.getAugur().createChildUniverse(_parentPayoutDistributionHash);
             childUniverses.push(_childUniverse);
             controller.getAugur().logUniverseCreated(_childUniverse);
         }

source/contracts/trading/CancelOrder.sol

@@ -9,6 +9,7 @@ import 'trading/ICancelOrder.sol';
 import 'Controlled.sol';
 import 'libraries/ReentrancyGuard.sol';
 import 'libraries/CashAutoConverter.sol';
+import 'libraries/MarketValidator.sol';
 import 'trading/Order.sol';
 import 'reporting/IMarket.sol';
 import 'trading/ICash.sol';
@@ -21,7 +22,7 @@ import 'libraries/Extractable.sol';
  * @title CancelOrder
  * @dev This allows you to cancel orders on the book.
  */
-contract CancelOrder is CashAutoConverter, Extractable, ReentrancyGuard, ICancelOrder {
+contract CancelOrder is CashAutoConverter, Extractable, ReentrancyGuard, MarketValidator, ICancelOrder {
     /**
      * @dev Cancellation: cancels an order, if a bid refunds money, if an ask returns shares
      * @return true if successful; throw on failure

source/contracts/trading/ClaimTradingProceeds.sol

@@ -5,6 +5,7 @@ import 'trading/IClaimTradingProceeds.sol';
 import 'Controlled.sol';
 import 'libraries/ReentrancyGuard.sol';
 import 'libraries/CashAutoConverter.sol';
+import 'libraries/MarketValidator.sol';
 import 'reporting/IMarket.sol';
 import 'trading/ICash.sol';
 import 'libraries/math/SafeMathUint256.sol';
@@ -18,10 +19,10 @@ import 'libraries/Extractable.sol';
  * @title ClaimTradingProceeds
  * @dev This allows users to claim their money from a market by exchanging their shares
  */
-contract ClaimTradingProceeds is CashAutoConverter, Extractable, ReentrancyGuard, IClaimTradingProceeds {
+contract ClaimTradingProceeds is CashAutoConverter, Extractable, ReentrancyGuard, MarketValidator, IClaimTradingProceeds {
     using SafeMathUint256 for uint256;
 
-    function claimTradingProceeds(IMarket _market) convertToAndFromCash onlyInGoodTimes nonReentrant external returns(bool) {
+    function claimTradingProceeds(IMarket _market) marketIsLegit(_market) convertToAndFromCash onlyInGoodTimes nonReentrant external returns(bool) {
         if (!_market.isFinalized()) {
             _market.finalize();
         }

source/contracts/trading/CompleteSets.sol

@@ -6,6 +6,7 @@ import 'Augur.sol';
 import 'Controlled.sol';
 import 'libraries/ReentrancyGuard.sol';
 import 'libraries/math/SafeMathUint256.sol';
+import 'libraries/MarketValidator.sol';
 import 'trading/ICash.sol';
 import 'reporting/IMarket.sol';
 import 'reporting/IFeeWindow.sol';
@@ -14,13 +15,13 @@ import 'libraries/CashAutoConverter.sol';
 import 'libraries/Extractable.sol';
 
 
-contract CompleteSets is Controlled, Extractable, CashAutoConverter, ReentrancyGuard, ICompleteSets {
+contract CompleteSets is Controlled, Extractable, CashAutoConverter, ReentrancyGuard, MarketValidator, ICompleteSets {
     using SafeMathUint256 for uint256;
 
     /**
      * Buys `_amount` shares of every outcome in the specified market.
     **/
-    function publicBuyCompleteSets(IMarket _market, uint256 _amount) external payable convertToAndFromCash onlyInGoodTimes nonReentrant returns (bool) {
+    function publicBuyCompleteSets(IMarket _market, uint256 _amount) external marketIsLegit(_market) payable convertToAndFromCash onlyInGoodTimes nonReentrant returns (bool) {
         return this.buyCompleteSets(msg.sender, _market, _amount);
     }
 
@@ -42,7 +43,7 @@ contract CompleteSets is Controlled, Extractable, CashAutoConverter, ReentrancyG
         return true;
     }
 
-    function publicSellCompleteSets(IMarket _market, uint256 _amount) external convertToAndFromCash onlyInGoodTimes nonReentrant returns (bool) {
+    function publicSellCompleteSets(IMarket _market, uint256 _amount) external marketIsLegit(_market) convertToAndFromCash onlyInGoodTimes nonReentrant returns (bool) {
         this.sellCompleteSets(msg.sender, _market, _amount);
         return true;
     }

source/contracts/trading/CreateOrder.sol

@@ -5,17 +5,18 @@ pragma solidity 0.4.18;
 
 import 'Controlled.sol';
 import 'libraries/ReentrancyGuard.sol';
+import 'libraries/MarketValidator.sol';
 import 'trading/Order.sol';
 import 'trading/ICreateOrder.sol';
 import 'libraries/CashAutoConverter.sol';
 import 'libraries/Extractable.sol';
 
 
-contract CreateOrder is CashAutoConverter, Extractable, ReentrancyGuard {
+contract CreateOrder is CashAutoConverter, Extractable, ReentrancyGuard, MarketValidator {
     using Order for Order.Data;
 
     // CONSIDER: Do we want the API to be in terms of shares as it is now, or would the desired amount of ETH to place be preferable? Would both be useful?
-    function publicCreateOrder(Order.Types _type, uint256 _attoshares, uint256 _displayPrice, IMarket _market, uint8 _outcome, bytes32 _betterOrderId, bytes32 _worseOrderId, bytes32 _tradeGroupId) external payable convertToAndFromCash onlyInGoodTimes nonReentrant returns (bytes32) {
+    function publicCreateOrder(Order.Types _type, uint256 _attoshares, uint256 _displayPrice, IMarket _market, uint8 _outcome, bytes32 _betterOrderId, bytes32 _worseOrderId, bytes32 _tradeGroupId) external payable marketIsLegit(_market) convertToAndFromCash onlyInGoodTimes nonReentrant returns (bytes32) {
         return this.createOrder(msg.sender, _type, _attoshares, _displayPrice, _market, _outcome, _betterOrderId, _worseOrderId, _tradeGroupId);
     }
 

source/contracts/trading/Order.sol

@@ -53,6 +53,7 @@ library Order {
     // Constructor
     //
 
+    // No validation is needed here as it is simply a librarty function for organizing data
     function create(IController _controller, address _creator, uint8 _outcome, Order.Types _type, uint256 _attoshares, uint256 _price, IMarket _market, bytes32 _betterOrderId, bytes32 _worseOrderId) internal view returns (Data) {
         require(_outcome < _market.getNumberOfOutcomes());
         require(_price < _market.getNumTicks());