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

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.1",
   "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

@@ -36,6 +36,11 @@ if "ERC20" in REALITYETH_CONTRACT:
 else:
     ERC20 = False
 
+if "Freezable" in REALITYETH_CONTRACT:
+    IS_FREEZE_SUPPORTED = True
+else:
+    IS_FREEZE_SUPPORTED = False
+
 print("Version is "+str(VERNUM))
 
 if VERNUM >= 2.1:
@@ -43,12 +48,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 +2426,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 +2572,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 +2610,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,12 +2644,173 @@ 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()
+
+    #@unittest.skipIf(WORKING_ONLY, "Not under construction")
+    def test_frozen(self):
+
+        if not IS_FREEZE_SUPPORTED:
+            print("Skipping test_frozen, not supported by this version")
+            return
+
+        k0 = self.web3.eth.accounts[0]
+        k3 = self.web3.eth.accounts[3]
+        k4 = self.web3.eth.accounts[4]
+        k5 = self.web3.eth.accounts[5]
+
+        if ERC20:
+            self._issueTokens(k0, 1000000, 1000000)
+            self._issueTokens(k3, 1000000, 1000000)
+            self._issueTokens(k4, 1000000, 1000000)
 
- 
+        # We'll set up a question that finalizes before the freeze date to check we can still get its result after the freeze
+        txid = self.rc0.functions.askQuestionERC20(
+            0,
+            "my early question",
+            self.arb0.address,
+            30,
+            0,
+            0
+            ,1100
+        ).transact(self._txargs())
+        early_question_id = calculate_question_id(self.rc0.address, 0, "my early question", self.arb0.address, 30, 0, 0, self.web3.eth.accounts[0], 0)
+        st = None
+        st = self.submitAnswerReturnUpdatedState( st, early_question_id, 1001, 0, 200, k3)
+        st = self.submitAnswerReturnUpdatedState( st, early_question_id, 1001, 200, 400, k3)
 
+        self.assertFalse(self.rc0.functions.isFinalized(early_question_id).call())
+        # Can't get result as not finalized
+        with self.assertRaises(TransactionFailed):
+            self.assertEqual(self.rc0.functions.resultFor(early_question_id).call(), to_answer_for_contract(1001))
 
+        self._advance_clock(40)
+        self.assertTrue(self.rc0.functions.isFinalized(early_question_id).call())
+        self.assertEqual(self.rc0.functions.resultFor(early_question_id).call(), to_answer_for_contract(1001))
 
+        txid = self.rc0.functions.askQuestionERC20(
+            0,
+            "my question",
+            self.arb0.address,
+            30,
+            0,
+            0
+            ,1100
+        ).transact(self._txargs())
+        question_id = calculate_question_id(self.rc0.address, 0, "my question", self.arb0.address, 30, 0, 0, self.web3.eth.accounts[0], 0)
 
+        # Start with the series we used before and make sure it goes through
+        st = None
+        st = self.submitAnswerReturnUpdatedState( st, question_id, 1001, 0, 200, k3)
+        st = self.submitAnswerReturnUpdatedState( st, question_id, 1001, 200, 400, k3)
+
+        freeze_ts = self.rc0.functions.freeze_ts().call()
+        self.assertTrue(freeze_ts == 0, "Freeze timestamp should be zero before freeze")
+        self.rc0.functions.setFreezeTimestamp(self._block_timestamp()).transact(self._txargs())
+        freeze_ts = self.rc0.functions.freeze_ts().call()
+        self.assertTrue(freeze_ts > 0, "Freeze timestamp should be not zero after freeze")
+
+        # You can no longer answer a question
+        with self.assertRaises(TransactionFailed):
+            self.submitAnswerReturnUpdatedState( st, question_id, 1001, 400, 800, k3)
+
+        # You can no longer request arbitration
+        fee = self.arb0.functions.getDisputeFee(encode_hex("0x00")).call()
+        txid = self.arb0.functions.requestArbitration(question_id, 0).transact(self._txargs(val=fee))
+        with self.assertRaises(TransactionFailed):
+            self.raiseOnZeroStatus(txid)
+
+        # The question will no longer finalize, even after the time has elapsed
+        self.assertFalse(self.rc0.functions.isFinalized(question_id).call())
+        self._advance_clock(40)
+        self.assertFalse(self.rc0.functions.isFinalized(question_id).call())
+        # Can't get result as not finalized
+        with self.assertRaises(TransactionFailed):
+            self.assertEqual(self.rc0.functions.resultFor(question_id).call(), to_answer_for_contract(1001))
+
+        # The question that was finalized before is still finalized
+        self.assertTrue(self.rc0.functions.isFinalized(early_question_id).call())
+        # You can still get the result
+        self.assertEqual(self.rc0.functions.resultFor(early_question_id).call(), to_answer_for_contract(1001))
+
+        # You can no longer ask a new question
+        with self.assertRaises(TransactionFailed):
+            txid = self.rc0.functions.askQuestionERC20(
+                0,
+                "my question xyz",
+                self.arb0.address,
+                30,
+                0,
+                0
+                ,1100
+            ).transact(self._txargs())
+            self.raiseOnZeroStatus(txid)
 
 
 if __name__ == '__main__':

package/development/contracts/BalanceHolder_ERC20.sol

@@ -1,21 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-only
-
-pragma solidity ^0.8.20;
-
-import {IERC20} from "./IERC20.sol";
-import {IBalanceHolder_ERC20} from "./IBalanceHolder_ERC20.sol";
-
-contract BalanceHolder_ERC20 is IBalanceHolder_ERC20 {
-    IERC20 public token;
-
-    mapping(address => uint256) public balanceOf;
-
-    event LogWithdraw(address indexed user, uint256 amount);
-
-    function withdraw() public {
-        uint256 bal = balanceOf[msg.sender];
-        balanceOf[msg.sender] = 0;
-        require(token.transfer(msg.sender, bal));
-        emit LogWithdraw(msg.sender, bal);
-    }
-}

package/development/contracts/IBalanceHolder_ERC20.sol

@@ -1,11 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-only
-
-pragma solidity 0.8.20;
-
-import "./IERC20.sol";
-
-interface IBalanceHolder_ERC20 {
-    function withdraw() external;
-    function balanceOf(address) external view returns (uint256);
-    function token() external view returns (IERC20);
-}