No longer rely entirely on constants for fork values. Manual methods exposed for requesting updates based on new information

Author: nuevoalex

source/contracts/reporting/IReputationToken.sol

@@ -15,5 +15,6 @@ contract IReputationToken is ITyped, ERC20 {
     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

@@ -34,6 +34,8 @@ 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);

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

@@ -23,11 +23,15 @@ contract ReputationToken is DelegationTarget, Extractable, ITyped, Initializable
     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;
     }
 
@@ -46,7 +50,9 @@ contract ReputationToken is DelegationTarget, Extractable, ITyped, Initializable
         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()));
+            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;
     }
 
@@ -112,6 +120,32 @@ contract ReputationToken is DelegationTarget, Extractable, ITyped, Initializable
         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;

source/contracts/reporting/Universe.sol

@@ -29,6 +29,8 @@ contract Universe is DelegationTarget, Extractable, ITyped, Initializable, IUniv
     bytes32 private tentativeWinningChildUniversePayoutDistributionHash;
     uint256 private forkEndTime;
     uint256 private forkReputationGoal;
+    uint256 private disputeThresholdForFork;
+    uint256 private initialReportMinValue;
     mapping(uint256 => IFeeWindow) private feeWindows;
     mapping(address => bool) private markets;
     mapping(bytes32 => IUniverse) private childUniverses;
@@ -45,6 +47,7 @@ contract Universe is DelegationTarget, Extractable, ITyped, Initializable, IUniv
         parentUniverse = _parentUniverse;
         parentPayoutDistributionHash = _parentPayoutDistributionHash;
         reputationToken = ReputationTokenFactory(controller.lookup("ReputationTokenFactory")).createReputationToken(controller, this);
+        updateForkValues();
         require(reputationToken != address(0));
         return true;
     }
@@ -54,18 +57,18 @@ contract Universe is DelegationTarget, Extractable, ITyped, Initializable, IUniv
         require(isContainerForMarket(IMarket(msg.sender)));
         forkingMarket = IMarket(msg.sender);
         forkEndTime = controller.getTimestamp() + Reporting.getForkDurationSeconds();
-        // We pre calculate the amount of REP needed to determine a winner early in a fork. We assume maximum possible fork inflation in every fork so this is hard to achieve with every subsequent fork and may become impossible in some universes.
-        if (parentUniverse != IUniverse(0)) {
-            uint256 _previousForkReputationGoal = parentUniverse.getForkReputationGoal();
-            forkReputationGoal = _previousForkReputationGoal + (_previousForkReputationGoal / Reporting.getForkMigrationPercentageBonusDivisor());
-        } else {
-            // We're using a hardcoded supply value instead of getting the total REP supply from the token since at launch we will start out with a 0 supply token and users will migrate legacy REP to this token. Since the first fork may occur before all REP migrates we want to count that unmigrated REP too since it may participate in the fork eventually.
-            forkReputationGoal = Reporting.getInitialREPSupply() / Reporting.getForkRepMigrationVictoryDivisor();
-        }
         controller.getAugur().logUniverseForked();
         return true;
     }
 
+    function updateForkValues() public returns (bool) {
+        uint256 _totalRepSupply = reputationToken.getTotalTheoreticalSupply();
+        forkReputationGoal = _totalRepSupply.div(2); // 50% of REP migrating results in a victory in a fork
+        disputeThresholdForFork = _totalRepSupply.div(80); // 1.25% of the total rep supply
+        initialReportMinValue = disputeThresholdForFork.div(3).div(2**18) + 1; // This value will result in a maximum 20 round dispute sequence
+        return true;
+    }
+
     function getTypeName() public view returns (bytes32) {
         return "Universe";
     }
@@ -94,6 +97,14 @@ contract Universe is DelegationTarget, Extractable, ITyped, Initializable, IUniv
         return forkReputationGoal;
     }
 
+    function getDisputeThresholdForFork() public view returns (uint256) {
+        return disputeThresholdForFork;
+    }
+
+    function getInitialReportMinValue() public view returns (uint256) {
+        return initialReportMinValue;
+    }
+
     function getFeeWindow(uint256 _feeWindowId) public view returns (IFeeWindow) {
         return feeWindows[_feeWindowId];
     }
@@ -319,7 +330,7 @@ contract Universe is DelegationTarget, Extractable, ITyped, Initializable, IUniv
         uint256 _incorrectDesignatedReportMarketsInPreviousWindow = _previousFeeWindow.getNumIncorrectDesignatedReportMarkets();
         uint256 _previousDesignatedReportStakeInAttoRep = designatedReportStakeInAttoRep[_previousFeeWindow];
 
-        _currentDesignatedReportStakeInAttoRep = calculateFloatingValue(_incorrectDesignatedReportMarketsInPreviousWindow, _totalMarketsInPreviousWindow, Reporting.getTargetIncorrectDesignatedReportMarketsDivisor(), _previousDesignatedReportStakeInAttoRep, Reporting.getDefaultDesignatedReportStake(), Reporting.getDesignatedReportStakeFloor());
+        _currentDesignatedReportStakeInAttoRep = calculateFloatingValue(_incorrectDesignatedReportMarketsInPreviousWindow, _totalMarketsInPreviousWindow, Reporting.getTargetIncorrectDesignatedReportMarketsDivisor(), _previousDesignatedReportStakeInAttoRep, initialReportMinValue, initialReportMinValue);
         designatedReportStakeInAttoRep[_feeWindow] = _currentDesignatedReportStakeInAttoRep;
         return _currentDesignatedReportStakeInAttoRep;
     }
@@ -335,7 +346,7 @@ contract Universe is DelegationTarget, Extractable, ITyped, Initializable, IUniv
         uint256 _designatedReportNoShowsInPreviousWindow = _previousFeeWindow.getNumDesignatedReportNoShows();
         uint256 _previousDesignatedReportNoShowBondInAttoRep = designatedReportNoShowBondInAttoRep[_previousFeeWindow];
 
-        _currentDesignatedReportNoShowBondInAttoRep = calculateFloatingValue(_designatedReportNoShowsInPreviousWindow, _totalMarketsInPreviousWindow, Reporting.getTargetDesignatedReportNoShowsDivisor(), _previousDesignatedReportNoShowBondInAttoRep, Reporting.getDefaultDesignatedReportNoShowBond(), Reporting.getDesignatedReportNoShowBondFloor());
+        _currentDesignatedReportNoShowBondInAttoRep = calculateFloatingValue(_designatedReportNoShowsInPreviousWindow, _totalMarketsInPreviousWindow, Reporting.getTargetDesignatedReportNoShowsDivisor(), _previousDesignatedReportNoShowBondInAttoRep, initialReportMinValue, initialReportMinValue);
         designatedReportNoShowBondInAttoRep[_feeWindow] = _currentDesignatedReportNoShowBondInAttoRep;
         return _currentDesignatedReportNoShowBondInAttoRep;
     }

tests/conftest.py

@@ -377,7 +377,7 @@ def createScalarMarket(self, universe, endTime, feePerEthInWei, denominationToke
     def createReasonableBinaryMarket(self, universe, denominationToken, sender=tester.k0, topic="", description="description", extraInfo=""):
         return self.createBinaryMarket(
             universe = universe,
-            endTime = long(self.chain.head_state.timestamp + timedelta(days=1).total_seconds()),
+            endTime = long(self.contracts["Time"].getTimestamp() + timedelta(days=1).total_seconds()),
             feePerEthInWei = 10**16,
             denominationToken = denominationToken,
             designatedReporterAddress = tester.a0,
@@ -390,7 +390,7 @@ def createReasonableCategoricalMarket(self, universe, numOutcomes, denominationT
         return self.createCategoricalMarket(
             universe = universe,
             numOutcomes = numOutcomes,
-            endTime = long(self.chain.head_state.timestamp + timedelta(days=1).total_seconds()),
+            endTime = long(self.contracts["Time"].getTimestamp() + timedelta(days=1).total_seconds()),
             feePerEthInWei = 10**16,
             denominationToken = denominationToken,
             designatedReporterAddress = tester.a0,
@@ -399,7 +399,7 @@ def createReasonableCategoricalMarket(self, universe, numOutcomes, denominationT
     def createReasonableScalarMarket(self, universe, maxPrice, minPrice, numTicks, denominationToken, sender=tester.k0):
         return self.createScalarMarket(
             universe = universe,
-            endTime = long(self.chain.head_state.timestamp + timedelta(days=1).total_seconds()),
+            endTime = long(self.contracts["Time"].getTimestamp() + timedelta(days=1).total_seconds()),
             feePerEthInWei = 10**16,
             denominationToken = denominationToken,
             maxPrice= maxPrice,