Merge pull request #512 from AugurProject/universe_changes

Universe changes

Author: nuevoalex

source/contracts/reporting/BaseReportingParticipant.sol

@@ -34,7 +34,7 @@ contract BaseReportingParticipant is Controlled, IReportingParticipant {
 
     function fork() public onlyInGoodTimes returns (bool) {
         require(market == market.getUniverse().getForkingMarket());
-        IUniverse _newUniverse = market.getUniverse().createChildUniverse(payoutDistributionHash);
+        IUniverse _newUniverse = market.getUniverse().createChildUniverse(payoutNumerators, invalid);
         IReputationToken _newReputationToken = _newUniverse.getReputationToken();
         redeemForAllFeeWindows();
         uint256 _balance = reputationToken.balanceOf(this);

source/contracts/reporting/IReputationToken.sol

@@ -14,5 +14,7 @@ contract IReputationToken is ITyped, ERC20 {
     function trustedFeeWindowTransfer(address _source, address _destination, uint256 _attotokens) public returns (bool);
     function trustedUniverseTransfer(address _source, address _destination, uint256 _attotokens) public returns (bool);
     function getUniverse() public view returns (IUniverse);
+    function getTotalMigrated() public view returns (uint256);
+    function getTotalTheoreticalSupply() public view returns (uint256);
     function mintForReportingParticipant(uint256 _amountMigrated) public returns (bool);
 }

source/contracts/reporting/IUniverse.sol

@@ -15,7 +15,7 @@ contract IUniverse is ITyped {
     function initialize(IUniverse _parentUniverse, bytes32 _parentPayoutDistributionHash) external returns (bool);
     function fork() public returns (bool);
     function getParentUniverse() public view returns (IUniverse);
-    function createChildUniverse(bytes32 _parentPayoutDistributionHash) public returns (IUniverse);
+    function createChildUniverse(uint256[] _parentPayoutNumerators, bool _invalid) public returns (IUniverse);
     function getChildUniverse(bytes32 _parentPayoutDistributionHash) public view returns (IUniverse);
     function getReputationToken() public view returns (IReputationToken);
     function getForkingMarket() public view returns (IMarket);
@@ -34,12 +34,15 @@ contract IUniverse is ITyped {
     function getOrCacheDesignatedReportStake() public returns (uint256);
     function getOrCacheDesignatedReportNoShowBond() public returns (uint256);
     function getOrCacheReportingFeeDivisor() public returns (uint256);
+    function getDisputeThresholdForFork() public view returns (uint256);
+    function getInitialReportMinValue() public view returns (uint256);
     function calculateFloatingValue(uint256 _badMarkets, uint256 _totalMarkets, uint256 _targetDivisor, uint256 _previousValue, uint256 _defaultValue, uint256 _floor) public pure returns (uint256 _newValue);
     function getOrCacheTargetReporterGasCosts() public returns (uint256);
     function getOrCacheMarketCreationCost() public returns (uint256);
     function getCurrentFeeWindow() public view returns (IFeeWindow);
     function getOrCreateFeeWindowBefore(IFeeWindow _feeWindow) public returns (IFeeWindow);
     function isParentOf(IUniverse _shadyChild) public view returns (bool);
+    function updateTentativeWinningChildUniverse(bytes32 _parentPayoutDistributionHash) public returns (bool);
     function isContainerForFeeWindow(IFeeWindow _shadyTarget) public view returns (bool);
     function isContainerForMarket(IMarket _shadyTarget) public view returns (bool);
     function isContainerForReportingParticipant(IReportingParticipant _reportingParticipant) public view returns (bool);

source/contracts/reporting/Market.sol

@@ -154,7 +154,7 @@ contract Market is DelegationTarget, Extractable, ITyped, Initializable, Ownable
         participants.push(_reportingParticipant);
         crowdsourcers = MapFactory(controller.lookup("MapFactory")).createMap(controller, this); // disavow other crowdsourcers
         controller.getAugur().logDisputeCrowdsourcerCompleted(universe, this, _reportingParticipant);
-        if (IDisputeCrowdsourcer(msg.sender).getSize() >= Reporting.getDisputeThresholdForFork()) {
+        if (IDisputeCrowdsourcer(msg.sender).getSize() >= universe.getDisputeThresholdForFork()) {
             universe.fork();
         } else {
             feeWindow = universe.getOrCreateNextFeeWindow();

source/contracts/reporting/Reporting.sol

@@ -8,13 +8,7 @@ library Reporting {
     uint256 private constant FORK_DURATION_SECONDS = 60 days;
 
     uint256 private constant INITIAL_REP_SUPPLY = 11 * 10 ** 6 * 10 ** 18; // 11 Million REP
-    // CONSIDER: Should this be a constant?
-    uint256 private constant DISPUTE_THRESHOLD_FOR_FORK = INITIAL_REP_SUPPLY / 80; // 1.25% of the REP total supply
-    uint256 private constant INITIAL_REPORT_MIN_VALUE = 175 * 10**15; // This value will result in a maximum 20 round dispute sequence
-    uint256 private constant DEFAULT_DESIGNATED_REPORT_STAKE = INITIAL_REPORT_MIN_VALUE;
-    uint256 private constant DESIGNATED_REPORT_STAKE_FLOOR = INITIAL_REPORT_MIN_VALUE;
-    uint256 private constant DEFAULT_DESIGNATED_REPORT_NO_SHOW_BOND = INITIAL_REPORT_MIN_VALUE;
-    uint256 private constant DESIGNATED_REPORT_NO_SHOW_BOND_FLOOR = INITIAL_REPORT_MIN_VALUE;
+    
     uint256 private constant DEFAULT_VALIDITY_BOND = 1 ether / 100;
     uint256 private constant VALIDITY_BOND_FLOOR = 1 ether / 100;
     uint256 private constant DEFAULT_REPORTING_FEE_DIVISOR = 100; // 1% fees
@@ -31,7 +25,6 @@ library Reporting {
     uint256 private constant TARGET_REP_MARKET_CAP_MULTIPLIER = 5;
 
     uint256 private constant FORK_MIGRATION_PERCENTAGE_BONUS_DIVISOR = 20; // 5% bonus to any REP migrated during a fork
-    uint256 private constant FORK_REP_MIGRATION_VICTORY_DIVISOR = 2; // 50% of the REP supply in the forking universe has to migrate for a victory
 
     function getDesignatedReportingDurationSeconds() internal pure returns (uint256) { return DESIGNATED_REPORTING_DURATION_SECONDS; }
     function getDisputeRoundDurationSeconds() internal pure returns (uint256) { return DISPUTE_ROUND_DURATION_SECONDS; }
@@ -40,22 +33,16 @@ library Reporting {
     function getGasToReport() internal pure returns (uint256) { return GAS_TO_REPORT; }
     function getDefaultReportingGasPrice() internal pure returns (uint256) { return DEFAULT_REPORTING_GAS_PRICE; }
     function getDefaultValidityBond() internal pure returns (uint256) { return DEFAULT_VALIDITY_BOND; }
-    function getDefaultDesignatedReportStake() internal pure returns (uint256) { return DEFAULT_DESIGNATED_REPORT_STAKE; }
-    function getDefaultDesignatedReportNoShowBond() internal pure returns (uint256) { return DEFAULT_DESIGNATED_REPORT_NO_SHOW_BOND; }
     function getValidityBondFloor() internal pure returns (uint256) { return VALIDITY_BOND_FLOOR; }
-    function getDesignatedReportStakeFloor() internal pure returns (uint256) { return DESIGNATED_REPORT_STAKE_FLOOR; }
-    function getDesignatedReportNoShowBondFloor() internal pure returns (uint256) { return DESIGNATED_REPORT_NO_SHOW_BOND_FLOOR; }
     function getTargetInvalidMarketsDivisor() internal pure returns (uint256) { return TARGET_INVALID_MARKETS_DIVISOR; }
     function getTargetIncorrectDesignatedReportMarketsDivisor() internal pure returns (uint256) { return TARGET_INCORRECT_DESIGNATED_REPORT_MARKETS_DIVISOR; }
     function getTargetDesignatedReportNoShowsDivisor() internal pure returns (uint256) { return TARGET_DESIGNATED_REPORT_NO_SHOWS_DIVISOR; }
     function getTargetRepMarketCapMultiplier() internal pure returns (uint256) { return TARGET_REP_MARKET_CAP_MULTIPLIER; }
     function getForkMigrationPercentageBonusDivisor() internal pure returns (uint256) { return FORK_MIGRATION_PERCENTAGE_BONUS_DIVISOR; }
-    function getForkRepMigrationVictoryDivisor() internal pure returns (uint256) { return FORK_REP_MIGRATION_VICTORY_DIVISOR; }
     function getMaximumReportingFeeDivisor() internal pure returns (uint256) { return MAXIMUM_REPORTING_FEE_DIVISOR; }
     function getMinimumReportingFeeDivisor() internal pure returns (uint256) { return MINIMUM_REPORTING_FEE_DIVISOR; }
     function getDefaultReportingFeeDivisor() internal pure returns (uint256) { return DEFAULT_REPORTING_FEE_DIVISOR; }
     function getInitialREPSupply() internal pure returns (uint256) { return INITIAL_REP_SUPPLY; }
-    function getDisputeThresholdForFork() internal pure returns (uint256) { return DISPUTE_THRESHOLD_FOR_FORK; }
 
     function getCategoricalMarketNumTicks(uint8 _numOutcomes) internal pure returns (uint256) {
         require(_numOutcomes >= 2 && _numOutcomes <= 8);

source/contracts/reporting/ReputationToken.sol

@@ -22,11 +22,16 @@ contract ReputationToken is DelegationTarget, Extractable, ITyped, Initializable
     string constant public symbol = "REP";
     uint256 constant public decimals = 18;
     IUniverse private universe;
+    uint256 private totalMigrated;
+    mapping(address => uint256) migratedToSibling;
+    uint256 private parentTotalTheoreticalSupply;
+    uint256 private totalTheoreticalSupply;
 
     function initialize(IUniverse _universe) public onlyInGoodTimes beforeInitialized returns (bool) {
         endInitialization();
         require(_universe != address(0));
         universe = _universe;
+        updateParentTotalTheoreticalSupply();
         return true;
     }
 
@@ -42,12 +47,13 @@ contract ReputationToken is DelegationTarget, Extractable, ITyped, Initializable
         IUniverse _parentUniverse = universe.getParentUniverse();
         require(ReputationToken(msg.sender) == _parentUniverse.getReputationToken());
         mint(_reporter, _attotokens);
-        // Award a bonus if migration is done before the fork has resolved and check if the fork can be resolved early
+        totalMigrated += _attotokens;
+        // Award a bonus if migration is done before the fork has resolved and update the universe tentative winner tracking
         if (!_parentUniverse.getForkingMarket().isFinalized()) {
-            mint(_reporter, _attotokens.div(Reporting.getForkMigrationPercentageBonusDivisor()));
-            if (supply > _parentUniverse.getForkReputationGoal()) {
-                _parentUniverse.getForkingMarket().finalizeFork();
-            }
+            uint256 _bonus = _attotokens.div(Reporting.getForkMigrationPercentageBonusDivisor());
+            mint(_reporter, _bonus);
+            totalTheoreticalSupply += _bonus;
+            _parentUniverse.updateTentativeWinningChildUniverse(universe.getParentPayoutDistributionHash());
         }
         return true;
     }
@@ -64,7 +70,9 @@ contract ReputationToken is DelegationTarget, Extractable, ITyped, Initializable
         IUniverse _parentUniverse = universe.getParentUniverse();
         IReportingParticipant _reportingParticipant = IReportingParticipant(msg.sender);
         require(_parentUniverse.isContainerForReportingParticipant(_reportingParticipant));
-        mint(_reportingParticipant, _amountMigrated / 2);
+        uint256 _bonus = _amountMigrated / 2;
+        mint(_reportingParticipant, _bonus);
+        totalTheoreticalSupply += _bonus;
         return true;
     }
 
@@ -108,6 +116,36 @@ contract ReputationToken is DelegationTarget, Extractable, ITyped, Initializable
         return universe;
     }
 
+    function getTotalMigrated() public view returns (uint256) {
+        return totalMigrated;
+    }
+
+    function updateSiblingMigrationTotal(IReputationToken _token) public returns (bool) {
+        require(_token != this);
+        IUniverse _supposedUniverse = _token.getUniverse();
+        require(_token == universe.getParentUniverse().getChildUniverse(_supposedUniverse.getParentPayoutDistributionHash()).getReputationToken());
+        totalTheoreticalSupply += migratedToSibling[_token];
+        migratedToSibling[_token] = _token.getTotalMigrated();
+        totalTheoreticalSupply -= migratedToSibling[_token];
+        return true;
+    }
+
+    function updateParentTotalTheoreticalSupply() public returns (bool) {
+        IUniverse _parentUniverse = universe.getParentUniverse();
+        totalTheoreticalSupply -= parentTotalTheoreticalSupply;
+        if (_parentUniverse == IUniverse(0)) {
+            parentTotalTheoreticalSupply = Reporting.getInitialREPSupply();
+        } else {
+            parentTotalTheoreticalSupply = _parentUniverse.getReputationToken().getTotalTheoreticalSupply();
+        }
+        totalTheoreticalSupply += parentTotalTheoreticalSupply;
+        return true;
+    }
+
+    function getTotalTheoreticalSupply() public view returns (uint256) {
+        return totalTheoreticalSupply;
+    }
+
     function onTokenTransfer(address _from, address _to, uint256 _value) internal returns (bool) {
         controller.getAugur().logReputationTokensTransferred(universe, _from, _to, _value);
         return true;