@reality.eth/contracts 3.0.48 → 4.0.0-rc.0

package/development/contracts/RealityETH_ERC20-4.0.sol

@@ -4,10 +4,11 @@ pragma solidity ^0.8.20;
 
 import {IERC20} from "./IERC20.sol";
 import {IRealityETHCore_ERC20} from "./IRealityETHCore_ERC20.sol";
+import {IRealityETHHistoryVerification} from "./IRealityETHHistoryVerification.sol";
 import {BalanceHolder_ERC20} from "./BalanceHolder_ERC20.sol";
 
 // solhint-disable-next-line contract-name-camelcase
-contract RealityETH_ERC20_v4_0 is BalanceHolder_ERC20, IRealityETHCore_ERC20 {
+contract RealityETH_ERC20_v4_0 is BalanceHolder_ERC20, IRealityETHCore_ERC20, IRealityETHHistoryVerification {
     address private constant NULL_ADDRESS = address(0);
 
     // History hash when no history is created, or history has been cleared
@@ -19,18 +20,12 @@ contract RealityETH_ERC20_v4_0 is BalanceHolder_ERC20, IRealityETHCore_ERC20 {
     // Proportion withheld when you claim an earlier bond.
     uint256 private constant BOND_CLAIM_FEE_PROPORTION = 40; // One 40th ie 2.5%
 
-    // Special value representing a question that was answered too soon.
-    // bytes32(-2). By convention we use bytes32(-1) for "invalid", although the contract does not handle this.
-    bytes32 private constant UNRESOLVED_ANSWER = 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe;
-
     uint256 private nextTemplateID = 0;
     mapping(uint256 => uint256) public templates;
     mapping(uint256 => bytes32) public template_hashes;
     mapping(bytes32 => Question) public questions;
     mapping(bytes32 => Claim) public question_claims;
     mapping(address => uint256) public arbitrator_question_fees;
-    mapping(bytes32 => bytes32) public reopened_questions;
-    mapping(bytes32 => bool) public reopener_questions;
 
     modifier onlyArbitrator(bytes32 question_id) {
         if (msg.sender != questions[question_id].arbitrator) revert MsgSenderMustBeArbitrator();
@@ -457,7 +452,9 @@ contract RealityETH_ERC20_v4_0 is BalanceHolder_ERC20, IRealityETHCore_ERC20 {
     /// @param last_answer The last answer given
     /// @param last_answerer The address that supplied the last answer
     function assignWinnerAndSubmitAnswerByArbitrator(bytes32 question_id, bytes32 answer, address payee_if_wrong, bytes32 last_history_hash, bytes32 last_answer, address last_answerer) external {
-        _verifyHistoryInputOrRevert(questions[question_id].history_hash, last_history_hash, last_answer, questions[question_id].bond, last_answerer);
+        if (!_isHistoryInputValidForHash(questions[question_id].history_hash, last_history_hash, last_answer, questions[question_id].bond, last_answerer)) {
+            revert HistoryInputProvidedDidNotMatchTheExpectedHash();
+        }
 
         address payee = (questions[question_id].best_answer == answer) ? last_answerer : payee_if_wrong;
         submitAnswerByArbitrator(question_id, answer, payee);
@@ -485,100 +482,6 @@ contract RealityETH_ERC20_v4_0 is BalanceHolder_ERC20, IRealityETHCore_ERC20 {
         return questions[question_id].best_answer;
     }
 
-    /// @notice Returns whether the question was answered before it had an answer, ie resolved to UNRESOLVED_ANSWER
-    /// @param question_id The ID of the question
-    function isSettledTooSoon(bytes32 question_id) public view returns (bool) {
-        return (resultFor(question_id) == UNRESOLVED_ANSWER);
-    }
-
-    /// @notice Like resultFor(), but errors out if settled too soon, or returns the result of a replacement if it was reopened at the right time and settled
-    /// @param question_id The ID of the question
-    function resultForOnceSettled(bytes32 question_id) external view returns (bytes32) {
-        bytes32 result = resultFor(question_id);
-        if (result == UNRESOLVED_ANSWER) {
-            // Try the replacement
-            bytes32 replacement_id = reopened_questions[question_id];
-            if (replacement_id == bytes32(0x0)) revert QuestionWasSettledTooSoonAndHasNotBeenReopened();
-            // We only try one layer down rather than recursing to keep the gas costs predictable
-            result = resultFor(replacement_id);
-            if (result == UNRESOLVED_ANSWER) revert QuestionReplacementWasSettledTooSoonAndHasNotBeenReopened();
-        }
-        return result;
-    }
-
-    /// @notice Asks a new question reopening a previously-asked question that was settled too soon
-    /// @dev A special version of askQuestion() that replaces a previous question that was settled too soon
-    /// @param template_id The ID number of the template the question will use
-    /// @param question A string containing the parameters that will be passed into the template to make the question
-    /// @param arbitrator The arbitration contract that will have the final word on the answer if there is a dispute
-    /// @param timeout How long the contract should wait after the answer is changed before finalizing on that answer
-    /// @param opening_ts If set, the earliest time it should be possible to answer the question.
-    /// @param nonce A user-specified nonce used in the question ID. Change it to repeat a question.
-    /// @param min_bond The minimum bond that can be used to provide the first answer.
-    /// @param reopens_question_id The ID of the question this reopens
-    /// @param tokens The number of tokens you want to use as an additional question reward for the reopened question.
-    /// @return The ID of the newly-created question, created deterministically.
-    function reopenQuestionERC20(
-        uint256 template_id,
-        string memory question,
-        address arbitrator,
-        uint32 timeout,
-        uint32 opening_ts,
-        uint256 nonce,
-        uint256 min_bond,
-        bytes32 reopens_question_id,
-        uint256 tokens
-    )
-        public
-        returns (
-            // stateNotCreated is enforced by the internal _askQuestion
-            bytes32
-        )
-    {
-        // _deductTokensOrRevert will be called when we call askQuestionWithMinBondERC20
-
-        if (!isSettledTooSoon(reopens_question_id)) revert YouCanOnlyReopenQuestionsThatResolvedAsSettledTooSoon();
-
-        bytes32 content_hash = keccak256(abi.encodePacked(template_id, opening_ts, question));
-
-        // A reopening must exactly match the original question, except for the nonce and the creator
-        if (content_hash != questions[reopens_question_id].content_hash) revert ContentHashMismatch();
-        if (arbitrator != questions[reopens_question_id].arbitrator) revert ArbitratorMismatch();
-        if (timeout != questions[reopens_question_id].timeout) revert TimeoutMismatch();
-        if (opening_ts != questions[reopens_question_id].opening_ts) revert Opening_TsMismatch();
-        if (min_bond != questions[reopens_question_id].min_bond) revert Min_BondMismatch();
-
-        // If the the question was itself reopening some previous question, you'll have to re-reopen the previous question first.
-        // This ensures the bounty can be passed on to the next attempt of the original question.
-        if (reopener_questions[reopens_question_id]) revert QuestionIsAlreadyReopeningAPreviousQuestion();
-
-        // A question can only be reopened once, unless the reopening was also settled too soon in which case it can be replaced
-        bytes32 existing_reopen_question_id = reopened_questions[reopens_question_id];
-
-        // Normally when we reopen a question we will take its bounty and pass it on to the reopened version.
-        bytes32 take_bounty_from_question_id = reopens_question_id;
-        // If the question has already been reopened but was again settled too soon, we can transfer its bounty to the next attempt.
-        if (existing_reopen_question_id != bytes32(0)) {
-            if (!isSettledTooSoon(existing_reopen_question_id)) revert QuestionHasAlreadyBeenReopened();
-            // We'll overwrite the reopening with our new question and move the bounty.
-            // Once that's done we'll detach the failed reopener and you'll be able to reopen that too if you really want, but without the bounty.
-            reopener_questions[existing_reopen_question_id] = false;
-            take_bounty_from_question_id = existing_reopen_question_id;
-        }
-
-        bytes32 question_id = askQuestionWithMinBondERC20(template_id, question, arbitrator, timeout, opening_ts, nonce, min_bond, tokens);
-
-        reopened_questions[reopens_question_id] = question_id;
-        reopener_questions[question_id] = true;
-
-        questions[question_id].bounty = questions[take_bounty_from_question_id].bounty + questions[question_id].bounty;
-        questions[take_bounty_from_question_id].bounty = 0;
-
-        emit LogReopenQuestion(question_id, reopens_question_id);
-
-        return question_id;
-    }
-
     /// @notice Return the final answer to the specified question, provided it matches the specified criteria.
     /// @dev Reverts if the question is not finalized, or if it does not match the specified criteria.
     /// @param question_id The ID of the question
@@ -625,7 +528,9 @@ contract RealityETH_ERC20_v4_0 is BalanceHolder_ERC20, IRealityETHCore_ERC20 {
 
         uint256 i;
         for (i = 0; i < history_hashes.length; i++) {
-            _verifyHistoryInputOrRevert(last_history_hash, history_hashes[i], answers[i], bonds[i], addrs[i]);
+            if (!_isHistoryInputValidForHash(last_history_hash, history_hashes[i], answers[i], bonds[i], addrs[i])) {
+                revert HistoryInputProvidedDidNotMatchTheExpectedHash();
+            }
 
             queued_funds = queued_funds + last_bond;
             (queued_funds, payee) = _processHistoryItem(question_id, best_answer, queued_funds, payee, addrs[i], bonds[i], answers[i]);
@@ -665,10 +570,13 @@ contract RealityETH_ERC20_v4_0 is BalanceHolder_ERC20, IRealityETHCore_ERC20 {
         emit LogClaim(question_id, payee, value);
     }
 
-    function _verifyHistoryInputOrRevert(bytes32 last_history_hash, bytes32 history_hash, bytes32 answer, uint256 bond, address addr) internal pure {
-        if (last_history_hash != keccak256(abi.encodePacked(history_hash, answer, bond, addr, false))) {
-            revert HistoryInputProvidedDidNotMatchTheExpectedHash();
-        }
+    function _isHistoryInputValidForHash(bytes32 last_history_hash, bytes32 history_hash, bytes32 answer, uint256 bond, address addr) internal pure returns (bool) {
+        return (last_history_hash == keccak256(abi.encodePacked(history_hash, answer, bond, addr, false)));
+    }
+
+    // The answered-too-soon version will override this with (answer != UNRESOLVED_ANSWER)
+    function _isBountyPayableOnAnswer(bytes32) internal pure virtual returns (bool) {
+        return true;
     }
 
     function _processHistoryItem(bytes32 question_id, bytes32 best_answer, uint256 queued_funds, address payee, address addr, uint256 bond, bytes32 answer) internal returns (uint256, address) {
@@ -678,7 +586,7 @@ contract RealityETH_ERC20_v4_0 is BalanceHolder_ERC20, IRealityETHCore_ERC20 {
                 // They get the question bounty.
                 payee = addr;
 
-                if (best_answer != UNRESOLVED_ANSWER && questions[question_id].bounty > 0) {
+                if (questions[question_id].bounty > 0 && _isBountyPayableOnAnswer(best_answer)) {
                     _payPayee(question_id, payee, questions[question_id].bounty);
                     questions[question_id].bounty = 0;
                 }
@@ -746,6 +654,40 @@ contract RealityETH_ERC20_v4_0 is BalanceHolder_ERC20, IRealityETHCore_ERC20 {
         withdraw();
     }
 
+    /// @notice Returns true if the supplied history is valid
+    /// @dev Caller must provide the answer history, in reverse order back to the item they want to check
+    /// @dev Not necessarily the entire history
+    /// @dev Useful for freezing an action once a bond is paid for a particular answer, without waiting for resolution
+    /// @dev Cannot be used after the question is finalized
+    /// @param question_id The ID of the question
+    /// @param history_hashes Second-last-to-first, the hash of each history entry. (Final one should be empty).
+    /// @param addrs Last-to-first, the address of each answerer
+    /// @param bonds Last-to-first, the bond supplied with each answer
+    /// @param answers Last-to-first, each answer supplied
+    function isHistoryOfUnfinalizedQuestionValid(
+        bytes32 question_id,
+        bytes32[] memory history_hashes,
+        address[] memory addrs,
+        uint256[] memory bonds,
+        bytes32[] memory answers
+    ) external view stateOpenOrPendingArbitration(question_id) returns (bool) {
+        bytes32 last_history_hash = questions[question_id].history_hash;
+
+        uint256 hist_len = history_hashes.length;
+        // Check for uneven length entries to make sure we validate all the inputs
+        if (addrs.length != hist_len || bonds.length != hist_len || answers.length != hist_len) {
+            return false;
+        }
+
+        for (uint256 i = 0; i < hist_len; i++) {
+            if (!_isHistoryInputValidForHash(last_history_hash, history_hashes[i], answers[i], bonds[i], addrs[i])) {
+                return false;
+            }
+            last_history_hash = history_hashes[i];
+        }
+        return true;
+    }
+
     /// @notice Returns the questions's content hash, identifying the question content
     /// @param question_id The ID of the question
     function getContentHash(bytes32 question_id) public view returns (bytes32) {

package/generated/chains.json

@@ -327,7 +327,7 @@
             "symbol": "ETH",
             "decimals": 18
         },
-        "network_name": "zksync-era-sepolia",
+        "network_name": "zksync-sepolia",
         "rpcUrls": [
             "https://sepolia.era.zksync.dev"
         ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reality.eth/contracts",
-  "version": "3.0.48",
+  "version": "4.0.0-rc.0",
   "description": "Collection of smart contracts for the Realitio fact verification platform",
   "scripts": {
     "generate-chains": "node scripts/generate_chains_json.js",
@@ -34,7 +34,7 @@
     "url": "https://github.com/RealityETH/monorepo/issues"
   },
   "homepage": "https://reality.eth.link",
-  "gitHead": "94611f2560bbff608c8c481d9ed6e65efba70159",
+  "gitHead": "03e4a48bc6ffcb5d327c5503fa1afb2eba3f97fb",
   "dependencies": {
     "ethers": "^5.6.8"
   }

package/tests/python/test.py

@@ -43,12 +43,27 @@ if VERNUM >= 2.1:
 else:
     CLAIM_FEE = 0
 
+if VERNUM == 3.0:
+    IS_ANSWERED_TOO_SOON_SUPPORTED = True
+elif VERNUM >= 4.0:
+    if "Reopenable" in REALITYETH_CONTRACT:
+        IS_ANSWERED_TOO_SOON_SUPPORTED = True
+    else:
+        IS_ANSWERED_TOO_SOON_SUPPORTED = False
+else:
+    # TODO: Add special version
+    IS_ANSWERED_TOO_SOON_SUPPORTED = False
+
 if VERNUM >= 4.0:
     IS_COMMIT_REVEAL_SUPPORTED = False
+    IS_PROVE_HISTORY_SUPPORTED = True
 else:
     IS_COMMIT_REVEAL_SUPPORTED = True
+    IS_PROVE_HISTORY_SUPPORTED = False
 
 print("IS_COMMIT_REVEAL_SUPPORTED is "+str(IS_COMMIT_REVEAL_SUPPORTED))
+print("IS_ANSWERED_TOO_SOON_SUPPORTED is "+str(IS_ANSWERED_TOO_SOON_SUPPORTED))
+print("CLAIM_FEE is "+str(CLAIM_FEE))
 
 DEPLOY_GAS = 8000000
 
@@ -2406,7 +2421,7 @@ class TestRealitio(TestCase):
     @unittest.skipIf(WORKING_ONLY, "Not under construction")
     def test_reopen_question(self):
 
-        if VERNUM < 3.0:
+        if not IS_ANSWERED_TOO_SOON_SUPPORTED:
             print("Skipping test_reopen_question, not a feature of this contract")
             return
 
@@ -2552,7 +2567,7 @@ class TestRealitio(TestCase):
     @unittest.skipIf(WORKING_ONLY, "Not under construction")
     def test_too_soon_bounty(self):
 
-        if VERNUM < 3.0:
+        if not IS_ANSWERED_TOO_SOON_SUPPORTED:
             print("Skipping test_reopen_question, not a feature of this contract")
             return
 
@@ -2590,8 +2605,8 @@ class TestRealitio(TestCase):
             print("Skipping test_too_soon_bonds_under_unrevealed_commit, contract does not support commit-reveal")
             return
 
-        if VERNUM < 3.0:
-            print("Skipping test_reopen_question, not a feature of this contract")
+        if not IS_ANSWERED_TOO_SOON_SUPPORTED:
+            print("Skipping test_too_soon_bonds_under_unrevealed_commit , not a feature of this contract")
             return
 
         k0 = self.web3.eth.accounts[0]
@@ -2624,13 +2639,74 @@ class TestRealitio(TestCase):
         
         self.assertEqual(self.rc0.functions.balanceOf(k3).call(), claimable)
 
+    #@unittest.skipIf(WORKING_ONLY, "Not under construction")
+    def test_is_history_of_unfinalized_question_valid(self):
+
+        if not IS_PROVE_HISTORY_SUPPORTED:
+            print("Skipping test_is_history_of_unfinalized_question_valid, not supported by this version")
+            return
+
+        k2 = self.web3.eth.accounts[2]
+        k3 = self.web3.eth.accounts[3]
+        k4 = self.web3.eth.accounts[4]
+
+        if ERC20:
+            self._issueTokens(k3, 100000, 50000)
+            self._issueTokens(k4, 100000, 50000)
+
+        st = None
+        st = self.submitAnswerReturnUpdatedState( st, self.question_id, 1001, 0, 20, k3)
+        st = self.submitAnswerReturnUpdatedState( st, self.question_id, 1002, 20, 40, k3)
+        st = self.submitAnswerReturnUpdatedState( st, self.question_id, 1001, 40, 80, k4)
+        st = self.submitAnswerReturnUpdatedState( st, self.question_id, 1004, 80, 160, k3)
+        st = self.submitAnswerReturnUpdatedState( st, self.question_id, 1003, 160, 320, k4)
+        st = self.submitAnswerReturnUpdatedState( st, self.question_id, 1001, 320, 640, k4)
+
+        hashes = st['hash']
+        addrs = st['addr']
+        bonds = st['bond']
+        answers = st['answer']
 
- 
+        self.assertTrue(self.rc0.functions.isHistoryOfUnfinalizedQuestionValid(self.question_id, hashes, addrs, bonds, answers).call())
 
+        bad_hashes = hashes.copy()
+        bad_hashes[2] = bad_hashes[1]
+        self.assertFalse(self.rc0.functions.isHistoryOfUnfinalizedQuestionValid(self.question_id, bad_hashes, addrs, bonds, answers).call())
 
+        bad_addrs = addrs.copy()
+        bad_addrs[2] = k2
+        self.assertFalse(self.rc0.functions.isHistoryOfUnfinalizedQuestionValid(self.question_id, hashes, bad_addrs, bonds, answers).call())
 
+        bad_bonds = bonds.copy()
+        bad_bonds[1] = 987
+        self.assertFalse(self.rc0.functions.isHistoryOfUnfinalizedQuestionValid(self.question_id, hashes, addrs, bad_bonds, answers).call())
 
+        bad_answers = answers.copy()
+        bad_answers[1] = to_answer_for_contract(987)
+        self.assertFalse(self.rc0.functions.isHistoryOfUnfinalizedQuestionValid(self.question_id, hashes, addrs, bonds, bad_answers).call())
 
+        # Supplying just the end of the list (lowest-bond answers) will fail
+        self.assertFalse(self.rc0.functions.isHistoryOfUnfinalizedQuestionValid(self.question_id, hashes[3:], addrs[3:], bonds[3:], answers[3:]).call())
+
+        # Supplying just the start of the list (highest-bond answers) will work
+        self.assertTrue(self.rc0.functions.isHistoryOfUnfinalizedQuestionValid(self.question_id, hashes[:3], addrs[:3], bonds[:3], answers[:3]).call())
+
+        # Any unevenness in the length of parameters passed will fail
+        self.assertFalse(self.rc0.functions.isHistoryOfUnfinalizedQuestionValid(self.question_id, hashes[:4], addrs[:3], bonds[:3], answers[:3]).call())
+        self.assertFalse(self.rc0.functions.isHistoryOfUnfinalizedQuestionValid(self.question_id, hashes[:3], addrs[:4], bonds[:3], answers[:3]).call())
+        self.assertFalse(self.rc0.functions.isHistoryOfUnfinalizedQuestionValid(self.question_id, hashes[:3], addrs[:3], bonds[:4], answers[:3]).call())
+        self.assertFalse(self.rc0.functions.isHistoryOfUnfinalizedQuestionValid(self.question_id, hashes[:3], addrs[:3], bonds[:3], answers[:4]).call())
+
+        self.assertFalse(self.rc0.functions.isHistoryOfUnfinalizedQuestionValid(self.question_id, hashes[:2], addrs[:3], bonds[:3], answers[:3]).call())
+        self.assertFalse(self.rc0.functions.isHistoryOfUnfinalizedQuestionValid(self.question_id, hashes[:3], addrs[:2], bonds[:3], answers[:3]).call())
+        self.assertFalse(self.rc0.functions.isHistoryOfUnfinalizedQuestionValid(self.question_id, hashes[:3], addrs[:3], bonds[:2], answers[:3]).call())
+        self.assertFalse(self.rc0.functions.isHistoryOfUnfinalizedQuestionValid(self.question_id, hashes[:3], addrs[:3], bonds[:3], answers[:2]).call())
+
+        self._advance_clock(33)
+
+        # Once we finalize this will revert
+        with self.assertRaises(TransactionFailed):
+            self.rc0.functions.isHistoryOfUnfinalizedQuestionValid(self.question_id, st['hash'], st['addr'], st['bond'], st['answer']).transact()
 
 if __name__ == '__main__':
     main()