@reality.eth/contracts 3.0.45 → 3.0.47

package/tests/python/test.py

@@ -43,6 +43,13 @@ if VERNUM >= 2.1:
 else:
     CLAIM_FEE = 0
 
+if VERNUM >= 4.0:
+    IS_COMMIT_REVEAL_SUPPORTED = False
+else:
+    IS_COMMIT_REVEAL_SUPPORTED = True
+
+print("IS_COMMIT_REVEAL_SUPPORTED is "+str(IS_COMMIT_REVEAL_SUPPORTED))
+
 DEPLOY_GAS = 8000000
 
 QINDEX_CONTENT_HASH = 0
@@ -67,7 +74,7 @@ def calculate_answer_hash(answer, nonce):
         raise Exception("hash functions expect bytes for bytes32 parameters")
     if not isinstance(nonce, int):
         raise Exception("hash functions expect int for uint256 parameters")
-    return "0x"+encode_hex(bytes(Web3.solidityKeccak(['bytes32', 'uint256'], [answer, nonce])))
+    return "0x"+encode_hex(bytes(Web3.solidity_keccak(['bytes32', 'uint256'], [answer, nonce])))
 
 def calculate_commitment_id(question_id, answer_hash, bond):
     if question_id[:2] == "0x":
@@ -77,20 +84,20 @@ def calculate_commitment_id(question_id, answer_hash, bond):
     if not isinstance(bond, int):
         raise Exception("hash functions expect int for uint256 parameters")
     #return decode_hex(keccak_256(question_id + answer_hash + decode_hex(hex(bond)[2:].zfill(64))).hexdigest())
-    return "0x"+encode_hex(bytes(Web3.solidityKeccak(['bytes32', 'bytes32', 'uint256'], [question_id, answer_hash, bond])))
+    return "0x"+encode_hex(bytes(Web3.solidity_keccak(['bytes32', 'bytes32', 'uint256'], [question_id, answer_hash, bond])))
 
 def calculate_content_hash(template_id, question_str, opening_ts):
-    return "0x"+encode_hex(bytes(Web3.solidityKeccak(['uint256', 'uint32', 'string'], [template_id, opening_ts, question_str])))
+    return "0x"+encode_hex(bytes(Web3.solidity_keccak(['uint256', 'uint32', 'string'], [template_id, opening_ts, question_str])))
 
 def calculate_question_id(cntrct, template_id, question_str, arbitrator, timeout, opening_ts, nonce, sender, min_bond):
     content_hash = calculate_content_hash(template_id, question_str, opening_ts)
     if VERNUM >= 3:
-        return "0x"+encode_hex(bytes(Web3.solidityKeccak(['bytes32', 'address', 'uint32', 'uint256', 'address', 'address', 'uint256'], [content_hash, arbitrator, timeout, min_bond, cntrct, sender, nonce])))
+        return "0x"+encode_hex(bytes(Web3.solidity_keccak(['bytes32', 'address', 'uint32', 'uint256', 'address', 'address', 'uint256'], [content_hash, arbitrator, timeout, min_bond, cntrct, sender, nonce])))
     else:
-        return "0x"+encode_hex(bytes(Web3.solidityKeccak(['bytes32', 'address', 'uint32', 'address', 'uint256'], [content_hash, arbitrator, timeout, sender, nonce])))
+        return "0x"+encode_hex(bytes(Web3.solidity_keccak(['bytes32', 'address', 'uint32', 'address', 'uint256'], [content_hash, arbitrator, timeout, sender, nonce])))
 
 def calculate_history_hash(last_history_hash, answer_or_commitment_id, bond, answerer, is_commitment):
-    return "0x"+encode_hex(bytes(Web3.solidityKeccak(['bytes32', 'bytes32', 'uint256', 'address', 'bool'], [last_history_hash, answer_or_commitment_id, bond, answerer, is_commitment])))
+    return "0x"+encode_hex(bytes(Web3.solidity_keccak(['bytes32', 'bytes32', 'uint256', 'address', 'bool'], [last_history_hash, answer_or_commitment_id, bond, answerer, is_commitment])))
 
 def from_question_for_contract(txt):
     return txt
@@ -156,13 +163,13 @@ class TestRealitio(TestCase):
 
 
     def assertZeroStatus(self, txid, msg=None):
-        self.assertEqual(self.web3.eth.getTransactionReceipt(txid)['status'], 0, msg)
+        self.assertEqual(self.web3.eth.get_transaction_receipt(txid)['status'], 0, msg)
 
     # Sometimes we seem to get a zero status receipt with no exception raised
     # Not sure if this is what's supposed to happen, but call this in the with block to make sure we get an exception 
     def raiseOnZeroStatus(self, txid):
-        if self.web3.eth.getTransactionReceipt(txid)['status'] == 0:
-            #print(self.web3.eth.getTransactionReceipt(txid))
+        if self.web3.eth.get_transaction_receipt(txid)['status'] == 0:
+            #print(self.web3.eth.get_transaction_receipt(txid))
             raise TransactionFailed
 
     def _block_timestamp(self):
@@ -208,7 +215,7 @@ class TestRealitio(TestCase):
             bcode = f.read().strip("\n")
             f.close()
 
-        for solcv in ['solc-0.4.25', 'solc-0.8.6']:
+        for solcv in ['solc-0.4.25', 'solc-0.8.6', 'solc-0.8.20']:
             abi_file = '../../abi/'+solcv+'/' + con_name + '.abi.json'
             if os.path.exists(abi_file):
                 with open(abi_file) as f:
@@ -217,7 +224,7 @@ class TestRealitio(TestCase):
                 break
 
         tx_hash = self.web3.eth.contract(abi=contract_if, bytecode=bcode).constructor().transact(self.deploy_tx)
-        addr = self.web3.eth.getTransactionReceipt(tx_hash).get('contractAddress')
+        addr = self.web3.eth.get_transaction_receipt(tx_hash).get('contractAddress')
         return self.web3.eth.contract(addr, abi=contract_if)
 
     def testS(self):
@@ -230,6 +237,7 @@ class TestRealitio(TestCase):
 
         prov = EthereumTesterProvider(EthereumTester(PyEVMBackend(genesis_params)))
         self.web3 = Web3(prov)
+        self.web3.strict_bytes_type_checking = False
         self.web3.testing.mine()
 
         self.deploy_tx = {
@@ -285,7 +293,7 @@ class TestRealitio(TestCase):
                 0,
                 0
             ).transact(self._txargs(val=1100))
-        txr = self.web3.eth.getTransactionReceipt(txid)
+        txr = self.web3.eth.get_transaction_receipt(txid)
 
         expected_content_hash = calculate_content_hash(0, "my question", 0)
 
@@ -558,6 +566,10 @@ class TestRealitio(TestCase):
             print("Skipping test_arbitrator_answering_assigning_answerer_right_commit, not a feature of this contract")
             return
 
+        if not IS_COMMIT_REVEAL_SUPPORTED:
+            print("Skipping test_arbitrator_answering_assigning_answerer_right_commit, contract does not support commit-reveal")
+            return
+
         k2 = self.web3.eth.accounts[2]
         k3 = self.web3.eth.accounts[3]
         k4 = self.web3.eth.accounts[4]
@@ -599,6 +611,10 @@ class TestRealitio(TestCase):
     @unittest.skipIf(WORKING_ONLY, "Not under construction")
     def test_arbitrator_answering_assigning_answerer_wrong_commit(self):
 
+        if not IS_COMMIT_REVEAL_SUPPORTED:
+            print("Skipping test_arbitrator_answering_assigning_answerer_wrong_commit, contract does not support commit-reveal")
+            return
+
         if VERNUM < 2.1:
             print("Skipping test_arbitrator_answering_assigning_answerer_wrong_commit, not a feature of this contract")
             return
@@ -689,6 +705,10 @@ class TestRealitio(TestCase):
     @unittest.skipIf(WORKING_ONLY, "Not under construction")
     def test_arbitrator_answering_assigning_answerer_unrevealed_commit(self):
 
+        if not IS_COMMIT_REVEAL_SUPPORTED:
+            print("Skipping test_arbitrator_answering_assigning_answerer_unrevealed_commit, contract does not support commit-reveal")
+            return
+
         if VERNUM < 2.1:
             print("Skipping test_arbitrator_answering_assigning_answerer_unrevealed_commit, not a feature of this contract")
             return
@@ -766,6 +786,10 @@ class TestRealitio(TestCase):
     @unittest.skipIf(WORKING_ONLY, "Not under construction")
     def test_arbitrator_answering_single_unrevealed_commit(self):
 
+        if not IS_COMMIT_REVEAL_SUPPORTED:
+            print("Skipping test_arbitrator_answering_single_unrevealed_commit, contract does not support commit-reveal")
+            return
+
         if VERNUM < 3.0:
             print("Skipping test_arbitrator_answering_assigning_answerer_single_unrevealed_commit, not a feature of this contract")
             return
@@ -871,6 +895,9 @@ class TestRealitio(TestCase):
 
     def submitAnswerReturnUpdatedState(self, st, qid, ans, max_last, bond, sdr, is_commitment = False, is_arbitrator = False, skip_sender = False, tx_acct = None):
 
+        if is_commitment and not IS_COMMIT_REVEAL_SUPPORTED:
+            raise Exception("Test tried to set is_commitment to true but the contract version does not support commitments")
+
         if tx_acct is None:
             tx_acct = sdr
 
@@ -1118,6 +1145,10 @@ class TestRealitio(TestCase):
     @unittest.skipIf(WORKING_ONLY, "Not under construction")
     def test_bond_claim_after_reveal_fail(self):
 
+        if not IS_COMMIT_REVEAL_SUPPORTED:
+            print("Skipping test_bond_claim_after_reveal_fail, contract does not support commit-reveal")
+            return
+
         k3 = self.web3.eth.accounts[3]
         k4 = self.web3.eth.accounts[4]
         k5 = self.web3.eth.accounts[5]
@@ -1132,7 +1163,7 @@ class TestRealitio(TestCase):
         st = None
         st = self.submitAnswerReturnUpdatedState( st, self.question_id, 1002,  0,  1, k3, False)
         st = self.submitAnswerReturnUpdatedState( st, self.question_id, 1001,  1,  2, k5, False)
-        st = self.submitAnswerReturnUpdatedState( st, self.question_id, 1003,  2,  4, k4, False) 
+        st = self.submitAnswerReturnUpdatedState( st, self.question_id, 1003,  2,  4, k4, False)
         st = self.submitAnswerReturnUpdatedState( st, self.question_id, 1002,  4,  8, k6, False)
         st = self.submitAnswerReturnUpdatedState( st, self.question_id, 1004,  8, 16, k5, True)
         st = self.submitAnswerReturnUpdatedState( st, self.question_id, 1002, 16, 32, k4, True)
@@ -1145,12 +1176,14 @@ class TestRealitio(TestCase):
     @unittest.skipIf(WORKING_ONLY, "Not under construction")
     def test_bond_claim_split_over_transactions_payee_later(self):
 
+        k2 = self.web3.eth.accounts[2]
         k3 = self.web3.eth.accounts[3]
         k4 = self.web3.eth.accounts[4]
         k5 = self.web3.eth.accounts[5]
         k6 = self.web3.eth.accounts[6]
 
         if ERC20:
+            self._issueTokens(k2, 1000000, 1000000)
             self._issueTokens(k3, 1000000, 1000000)
             self._issueTokens(k4, 1000000, 1000000)
             self._issueTokens(k5, 1000000, 1000000)
@@ -1159,7 +1192,41 @@ class TestRealitio(TestCase):
         st = None
         st = self.submitAnswerReturnUpdatedState( st, self.question_id, 1002,  0,  1, k3, False)
         st = self.submitAnswerReturnUpdatedState( st, self.question_id, 1001,  1,  2, k5, False)
-        st = self.submitAnswerReturnUpdatedState( st, self.question_id, 1003,  2,  4, k4, False) 
+        st = self.submitAnswerReturnUpdatedState( st, self.question_id, 1003,  2,  4, k4, False)
+        st = self.submitAnswerReturnUpdatedState( st, self.question_id, 1002,  4,  8, k6, False)
+        st = self.submitAnswerReturnUpdatedState( st, self.question_id, 1004,  8, 16, k5, False)
+        st = self.submitAnswerReturnUpdatedState( st, self.question_id, 1002, 16, 32, k2, False)
+
+        self._advance_clock(33)
+        self.rc0.functions.claimWinnings(self.question_id, st['hash'][:2], st['addr'][:2], st['bond'][:2], st['answer'][:2]).transact()
+        self.rc0.functions.claimWinnings(self.question_id, st['hash'][2:], st['addr'][2:], st['bond'][2:], st['answer'][2:]).transact()
+
+        self.assertEqual(self.rc0.functions.balanceOf(k2).call(),32+16-8+1000)
+        self.assertEqual(self.rc0.functions.balanceOf(k6).call(),8+8+4+2-1)
+        self.assertEqual(self.rc0.functions.balanceOf(k3).call(),1+1)
+
+    @unittest.skipIf(WORKING_ONLY, "Not under construction")
+    def test_bond_claim_split_over_transactions_payee_later_unrevealed_commit(self):
+
+        if not IS_COMMIT_REVEAL_SUPPORTED:
+            print("Skipping test_bond_claim_split_over_transactions_payee_later_unrevealed_commit, contract does not support commit-reveal")
+            return
+
+        k3 = self.web3.eth.accounts[3]
+        k4 = self.web3.eth.accounts[4]
+        k5 = self.web3.eth.accounts[5]
+        k6 = self.web3.eth.accounts[6]
+
+        if ERC20:
+            self._issueTokens(k3, 1000000, 1000000)
+            self._issueTokens(k4, 1000000, 1000000)
+            self._issueTokens(k5, 1000000, 1000000)
+            self._issueTokens(k6, 1000000, 1000000)
+
+        st = None
+        st = self.submitAnswerReturnUpdatedState( st, self.question_id, 1002,  0,  1, k3, False)
+        st = self.submitAnswerReturnUpdatedState( st, self.question_id, 1001,  1,  2, k5, False)
+        st = self.submitAnswerReturnUpdatedState( st, self.question_id, 1003,  2,  4, k4, False)
         st = self.submitAnswerReturnUpdatedState( st, self.question_id, 1002,  4,  8, k6, False)
         st = self.submitAnswerReturnUpdatedState( st, self.question_id, 1004,  8, 16, k5, True)
         st = self.submitAnswerReturnUpdatedState( st, self.question_id, 1002, 16, 32, k4, True)
@@ -1172,12 +1239,21 @@ class TestRealitio(TestCase):
 
     @unittest.skipIf(WORKING_ONLY, "Not under construction")
     def test_answer_reveal_calculation(self):
+
+        if not IS_COMMIT_REVEAL_SUPPORTED:
+            print("Skipping test_answer_reveal_calculation, contract does not support commit-reveal")
+            return
+
         h = calculate_answer_hash(to_answer_for_contract(1003), 94989)
         self.assertEqual(h, '0x23e796d2bf4f5f890b1242934a636f4802aadd480b6f83c754d2bd5920f78845')
 
     @unittest.skipIf(WORKING_ONLY, "Not under construction")
     def test_answer_commit_normal(self):
 
+        if not IS_COMMIT_REVEAL_SUPPORTED:
+            print("Skipping test_answer_commit_normal, contract does not support commit-reveal")
+            return
+
         k3 = self.web3.eth.accounts[3]
         k4 = self.web3.eth.accounts[4]
         k5 = self.web3.eth.accounts[5]
@@ -1222,7 +1298,7 @@ class TestRealitio(TestCase):
 
         self.raiseOnZeroStatus(txid)
 
-        #rcp = self.web3.eth.getTransactionReceipt(txid)
+        #rcp = self.web3.eth.get_transaction_receipt(txid)
         self._advance_clock(33)
         #time.sleep(10)
 
@@ -1234,6 +1310,11 @@ class TestRealitio(TestCase):
 
     @unittest.skipIf(WORKING_ONLY, "Not under construction")
     def test_answer_commit_skip_sender(self):
+
+        if not IS_COMMIT_REVEAL_SUPPORTED:
+            print("Skipping test_answer_commit_skip_sender, contract does not support commit-reveal")
+            return
+
         st = None
 
         k3 = self.web3.eth.accounts[3]
@@ -1267,6 +1348,10 @@ class TestRealitio(TestCase):
     @unittest.skipIf(WORKING_ONLY, "Not under construction")
     def test_answer_no_answer_no_commit(self):
 
+        if not IS_COMMIT_REVEAL_SUPPORTED:
+            print("Skipping test_answer_no_answer_no_commit, contract does not support commit-reveal")
+            return
+
         k3 = self.web3.eth.accounts[3]
         if ERC20:
             self._issueTokens(k3, 1000000, 1000000)
@@ -1291,6 +1376,10 @@ class TestRealitio(TestCase):
     @unittest.skipIf(WORKING_ONLY, "Not under construction")
     def test_answer_commit_expired(self):
 
+        if not IS_COMMIT_REVEAL_SUPPORTED:
+            print("Skipping test_answer_commit_expired, contract does not support commit-reveal")
+            return
+
         k3 = self.web3.eth.accounts[3]
         if ERC20:
             self._issueTokens(k3, 1000000, 1000000)
@@ -1308,6 +1397,10 @@ class TestRealitio(TestCase):
     @unittest.skipIf(WORKING_ONLY, "Not under construction")
     def test_answer_commit_with_arbitration_pending(self):
     
+        if not IS_COMMIT_REVEAL_SUPPORTED:
+            print("Skipping test_answer_commit_with_arbitration_pending, contract does not support commit-reveal")
+            return
+
         k3 = self.web3.eth.accounts[3]
         if ERC20:
             self._issueTokens(k3, 1000, 1000)
@@ -1664,17 +1757,17 @@ class TestRealitio(TestCase):
         if ERC20:
             starting_bal = self.token0.functions.balanceOf(k5).call()
         else:
-            starting_bal = self.web3.eth.getBalance(k5)
+            starting_bal = self.web3.eth.get_balance(k5)
 
         txid = self.rc0.functions.withdraw().transact(self._txargs(sender=k5))
-        rcpt = self.web3.eth.getTransactionReceipt(txid)
-        gas_spent = rcpt['cumulativeGasUsed']
+        rcpt = self.web3.eth.get_transaction_receipt(txid)
+        gas_spent = rcpt['cumulativeGasUsed'] * rcpt['effectiveGasPrice']
 
         if ERC20:
             ending_bal = self.token0.functions.balanceOf(k5).call()
             self.assertEqual(ending_bal, starting_bal + k5bal)
         else:
-            ending_bal = self.web3.eth.getBalance(k5)
+            ending_bal = self.web3.eth.get_balance(k5)
             self.assertEqual(ending_bal, starting_bal + k5bal - gas_spent)
 
         self.assertEqual(self.rc0.functions.balanceOf(k5).call(), 0)
@@ -1731,23 +1824,24 @@ class TestRealitio(TestCase):
         if ERC20:
             starting_bal = self.token0.functions.balanceOf(k5).call()
         else:
-            starting_bal = self.web3.eth.getBalance(k5)
+            starting_bal = self.web3.eth.get_balance(k5)
 
         txid = self.rc0.functions.withdraw().transact(self._txargs(sender=k5))
-        rcpt = self.web3.eth.getTransactionReceipt(txid)
+        rcpt = self.web3.eth.get_transaction_receipt(txid)
         gas_used = rcpt['cumulativeGasUsed']
+        gas_spent = gas_used * rcpt['effectiveGasPrice']
 
         if ERC20:
             ending_bal = self.token0.functions.balanceOf(k5).call()
         else:
-            ending_bal = self.web3.eth.getBalance(k5)
+            ending_bal = self.web3.eth.get_balance(k5)
 
         self.assertEqual(self.rc0.functions.balanceOf(k5).call(), 0)
 
         if ERC20:
             self.assertEqual(ending_bal, starting_bal + starting_deposited)
         else:
-            self.assertEqual(ending_bal, starting_bal + starting_deposited - gas_used)
+            self.assertEqual(ending_bal, starting_bal + starting_deposited - gas_spent)
 
         return
 
@@ -1792,16 +1886,16 @@ class TestRealitio(TestCase):
         if ERC20:
             starting_bal = self.token0.functions.balanceOf(k5).call()
         else:
-            starting_bal = self.web3.eth.getBalance(k5)
+            starting_bal = self.web3.eth.get_balance(k5)
 
         txid = self.rc0.functions.withdraw().transact(self._txargs(sender=k5))
-        rcpt = self.web3.eth.getTransactionReceipt(txid)
+        rcpt = self.web3.eth.get_transaction_receipt(txid)
         gas_used = rcpt['cumulativeGasUsed']
 
         if ERC20:
             ending_bal = self.token0.functions.balanceOf(k5).call()
         else:
-            ending_bal = self.web3.eth.getBalance(k5)
+            ending_bal = self.web3.eth.get_balance(k5)
 
         self.assertEqual(self.rc0.functions.balanceOf(k5).call(), 0)
 
@@ -1870,7 +1964,7 @@ class TestRealitio(TestCase):
                 0
                 ,1100
             ).transact()
-            rcpt = self.web3.eth.getTransactionReceipt(txid)
+            rcpt = self.web3.eth.get_transaction_receipt(txid)
             gas_used = rcpt['cumulativeGasUsed']
             self.assertTrue(gas_used < 140000)
         else:
@@ -1882,7 +1976,7 @@ class TestRealitio(TestCase):
                 0,
                 0
             ).transact(self._txargs(val=1100))
-            rcpt = self.web3.eth.getTransactionReceipt(txid)
+            rcpt = self.web3.eth.get_transaction_receipt(txid)
             gas_used = rcpt['cumulativeGasUsed']
             #self.assertEqual(gas_used, 120000)
             self.assertTrue(gas_used < 110000)
@@ -1895,7 +1989,7 @@ class TestRealitio(TestCase):
             txid = self.rc0.functions.submitAnswerERC20(self.question_id, to_answer_for_contract(12345), 0
             ,1
             ).transact()
-            rcpt = self.web3.eth.getTransactionReceipt(txid)
+            rcpt = self.web3.eth.get_transaction_receipt(txid)
 
             self.assertTrue(rcpt['cumulativeGasUsed'] < 140000)
 
@@ -1905,13 +1999,13 @@ class TestRealitio(TestCase):
             txid2 = self.rc0.functions.submitAnswerERC20(self.question_id, to_answer_for_contract(12346), 0
             ,2
             ).transact()
-            rcpt = self.web3.eth.getTransactionReceipt(txid2)
+            rcpt = self.web3.eth.get_transaction_receipt(txid2)
             self.assertTrue(rcpt['cumulativeGasUsed'] < 80000)
 
         else:
 
             txid = self.rc0.functions.submitAnswer(self.question_id, to_answer_for_contract(12345), 0).transact(self._txargs(val=1))
-            rcpt = self.web3.eth.getTransactionReceipt(txid)
+            rcpt = self.web3.eth.get_transaction_receipt(txid)
 
             self.assertTrue(rcpt['cumulativeGasUsed'] < 103000)
 
@@ -1919,7 +2013,7 @@ class TestRealitio(TestCase):
             # This is what we want, because you may need to be able to get a challenge through at busy times
 
             txid2 = self.rc0.functions.submitAnswer(self.question_id, to_answer_for_contract(12346), 0).transact(self._txargs(val=2)) 
-            rcpt = self.web3.eth.getTransactionReceipt(txid2)
+            rcpt = self.web3.eth.get_transaction_receipt(txid2)
             self.assertTrue(rcpt['cumulativeGasUsed'] < 56000)
 
     @unittest.skipIf(WORKING_ONLY, "Not under construction")
@@ -1967,7 +2061,7 @@ class TestRealitio(TestCase):
 
             start_arb_bal = self.token0.functions.balanceOf(self.arb0.address).call()
             txid = self.arb0.functions.callWithdraw().transact(self._txargs(sender=k7))
-            rcpt = self.web3.eth.getTransactionReceipt(txid)
+            rcpt = self.web3.eth.get_transaction_receipt(txid)
             end_arb_bal = self.token0.functions.balanceOf(self.arb0.address).call()
 
             self.assertEqual(end_arb_bal - start_arb_bal, 100 + (321*2))
@@ -1996,10 +2090,10 @@ class TestRealitio(TestCase):
             end_bal = self.rc0.functions.balanceOf(self.arb0.address).call()
             self.assertEqual(end_bal - start_bal, (321*2))
 
-            start_arb_bal = self.web3.eth.getBalance(self.arb0.address)
+            start_arb_bal = self.web3.eth.get_balance(self.arb0.address)
             txid = self.arb0.functions.callWithdraw().transact(self._txargs(sender=k7))
-            rcpt = self.web3.eth.getTransactionReceipt(txid)
-            end_arb_bal = self.web3.eth.getBalance(self.arb0.address)
+            rcpt = self.web3.eth.get_transaction_receipt(txid)
+            end_arb_bal = self.web3.eth.get_balance(self.arb0.address)
 
         self.assertEqual(end_arb_bal - start_arb_bal, 100 + (321*2))
         self.assertEqual(self.rc0.functions.balanceOf(self.arb0.address).call(), 0)
@@ -2120,11 +2214,11 @@ class TestRealitio(TestCase):
                 1100
             ).transact(self._txargs())
             bal_after = self.token0.functions.balanceOf(k0).call()
-            rcpt = self.web3.eth.getTransactionReceipt(txid)
+            rcpt = self.web3.eth.get_transaction_receipt(txid)
             self.assertEqual(bal_after, bal_before - 1100, "New question bounty is deducted")
             gas_used = rcpt['cumulativeGasUsed']
         else:
-            bal_before = self.web3.eth.getBalance(k0)
+            bal_before = self.web3.eth.get_balance(k0)
             txid = self.rc0.functions.askQuestionWithMinBond(
                 0,
                 "my question 2",
@@ -2134,10 +2228,11 @@ class TestRealitio(TestCase):
                 0,
                 1000
             ).transact(self._txargs(val=1100))
-            rcpt = self.web3.eth.getTransactionReceipt(txid)
+            rcpt = self.web3.eth.get_transaction_receipt(txid)
             gas_used = rcpt['cumulativeGasUsed']
-            bal_after = self.web3.eth.getBalance(k0)
-            self.assertEqual(bal_after, bal_before - 1100 - gas_used, "New question bouny is deducted")
+            gas_spent = gas_used * rcpt['effectiveGasPrice']
+            bal_after = self.web3.eth.get_balance(k0)
+            self.assertEqual(bal_after, bal_before - 1100 - gas_spent, "New question bouny is deducted")
 
         #self.assertEqual(gas_used, 120000)
         self.assertTrue(gas_used < 160000)
@@ -2263,7 +2358,7 @@ class TestRealitio(TestCase):
         if ERC20:
             start_arb_bal = self.token0.functions.balanceOf(t.a8).call()
         else:
-            start_arb_bal = self.web3.eth.getBalance(t.a8)
+            start_arb_bal = self.web3.eth.get_balance(t.a8)
 
         self.arb0.functions.callWithdraw().transact(self._txargs(sender=k7))
         self.arb0.functions.withdrawToRegisteredWallet().transact(self._txargs(sender=k4))
@@ -2271,7 +2366,7 @@ class TestRealitio(TestCase):
         if ERC20:
             end_arb_bal = self.token0.functions.balanceOf(t.a8).call()
         else:
-            end_arb_bal = self.web3.eth.getBalance(t.a8)
+            end_arb_bal = self.web3.eth.get_balance(t.a8)
 
         self.assertEqual(end_arb_bal - start_arb_bal, (100+321+321))
         self.assertEqual(self.rc0.functions.balanceOf(self.arb0.address).call(), 0)
@@ -2359,19 +2454,20 @@ class TestRealitio(TestCase):
             self.rc0.functions.withdraw().transact(self._txargs())
             bal_before = self.token0.functions.balanceOf(k0).call()
             txid = self.rc0.functions.reopenQuestionERC20( 0, "my question", self.arb0.address, 30, 0, 1, 0, self.question_id, 123).transact(self._txargs(gas=300000))
-            rcpt = self.web3.eth.getTransactionReceipt(txid)
+            rcpt = self.web3.eth.get_transaction_receipt(txid)
             self.raiseOnZeroStatus(txid)
             bal_after = self.token0.functions.balanceOf(k0).call()
             self.assertEqual(bal_after, bal_before - 123, "New question bounty is deducted")
         else:
-            bal_before = self.web3.eth.getBalance(k0)
+            bal_before = self.web3.eth.get_balance(k0)
             txid = self.rc0.functions.reopenQuestion( 0, "my question", self.arb0.address, 30, 0, 1, 0, self.question_id).transact(self._txargs(val=123))
             self.raiseOnZeroStatus(txid)
-            rcpt = self.web3.eth.getTransactionReceipt(txid)
-            gas_spent = rcpt['cumulativeGasUsed']
-            bal_after = self.web3.eth.getBalance(k0)
+            rcpt = self.web3.eth.get_transaction_receipt(txid)
+            gas_used = rcpt['cumulativeGasUsed']
+            gas_spent = gas_used * rcpt['effectiveGasPrice']
+            bal_after = self.web3.eth.get_balance(k0)
             self.assertEqual(bal_after, bal_before - 123 - gas_spent, "New question bounty is deducted")
-        txr = self.web3.eth.getTransactionReceipt(txid)
+        txr = self.web3.eth.get_transaction_receipt(txid)
 
         self.assertEqual("0x"+encode_hex(self.rc0.functions.reopened_questions(self.question_id).call()), expected_reopen_id, "reopened_questions returns reopened question id")
 
@@ -2394,7 +2490,7 @@ class TestRealitio(TestCase):
         # Different nonce should still fail
         with self.assertRaises(TransactionFailed):
             if ERC20:
-                txid = self.rc0.functions.reopenQuestionERC20( 0, "my question", self.arb0.address, 30, 0, 2, 0, self.question_id, 123).transact(self._txargs(val=123))
+                txid = self.rc0.functions.reopenQuestionERC20( 0, "my question", self.arb0.address, 30, 0, 2, 0, self.question_id, 123).transact(self._txargs())
             else:
                 txid = self.rc0.functions.reopenQuestion( 0, "my question", self.arb0.address, 30, 0, 2, 0, self.question_id).transact(self._txargs(val=123))
             self.raiseOnZeroStatus(txid)
@@ -2490,6 +2586,10 @@ class TestRealitio(TestCase):
     @unittest.skipIf(WORKING_ONLY, "Not under construction")
     def test_too_soon_bonds_under_unrevealed_commit(self):
 
+        if not IS_COMMIT_REVEAL_SUPPORTED:
+            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")
             return

package/tests/python/test_erc20.py

@@ -55,7 +55,7 @@ def calculate_answer_hash(answer, nonce):
         raise Exception("hash functions expect bytes for bytes32 parameters")
     if not isinstance(nonce, int):
         raise Exception("hash functions expect int for uint256 parameters")
-    return "0x"+encode_hex(bytes(Web3.solidityKeccak(['bytes32', 'uint256'], [answer, nonce])))
+    return "0x"+encode_hex(bytes(Web3.solidity_keccak(['bytes32', 'uint256'], [answer, nonce])))
 
 def calculate_commitment_id(question_id, answer_hash, bond):
     if question_id[:2] == "0x":
@@ -65,17 +65,17 @@ def calculate_commitment_id(question_id, answer_hash, bond):
     if not isinstance(bond, int):
         raise Exception("hash functions expect int for uint256 parameters")
     #return decode_hex(keccak_256(question_id + answer_hash + decode_hex(hex(bond)[2:].zfill(64))).hexdigest())
-    return "0x"+encode_hex(bytes(Web3.solidityKeccak(['bytes32', 'bytes32', 'uint256'], [question_id, answer_hash, bond])))
+    return "0x"+encode_hex(bytes(Web3.solidity_keccak(['bytes32', 'bytes32', 'uint256'], [question_id, answer_hash, bond])))
 
 def calculate_content_hash(template_id, question_str, opening_ts):
-    return "0x"+encode_hex(bytes(Web3.solidityKeccak(['uint256', 'uint32', 'string'], [template_id, opening_ts, question_str])))
+    return "0x"+encode_hex(bytes(Web3.solidity_keccak(['uint256', 'uint32', 'string'], [template_id, opening_ts, question_str])))
 
 def calculate_question_id(template_id, question_str, arbitrator, timeout, opening_ts, nonce, sender):
     content_hash = calculate_content_hash(template_id, question_str, opening_ts)
-    return "0x"+encode_hex(bytes(Web3.solidityKeccak(['bytes32', 'address', 'uint32', 'address', 'uint256'], [content_hash, arbitrator, timeout, sender, nonce])))
+    return "0x"+encode_hex(bytes(Web3.solidity_keccak(['bytes32', 'address', 'uint32', 'address', 'uint256'], [content_hash, arbitrator, timeout, sender, nonce])))
 
 def calculate_history_hash(last_history_hash, answer_or_commitment_id, bond, answerer, is_commitment):
-    return "0x"+encode_hex(bytes(Web3.solidityKeccak(['bytes32', 'bytes32', 'uint256', 'address', 'bool'], [last_history_hash, answer_or_commitment_id, bond, answerer, is_commitment])))
+    return "0x"+encode_hex(bytes(Web3.solidity_keccak(['bytes32', 'bytes32', 'uint256', 'address', 'bool'], [last_history_hash, answer_or_commitment_id, bond, answerer, is_commitment])))
 
 def from_question_for_contract(txt):
     return txt
@@ -90,13 +90,13 @@ def from_answer_for_contract(txt):
 class TestRealitio(TestCase):
 
     def assertZeroStatus(self, txid, msg=None):
-        self.assertEqual(self.web3.eth.getTransactionReceipt(txid)['status'], 0, msg)
+        self.assertEqual(self.web3.eth.get_transaction_receipt(txid)['status'], 0, msg)
 
     # Sometimes we seem to get a zero status receipt with no exception raised
     # Not sure if this is what's supposed to happen, but call this in the with block to make sure we get an exception 
     def raiseOnZeroStatus(self, txid):
-        if self.web3.eth.getTransactionReceipt(txid)['status'] == 0:
-            #print(self.web3.eth.getTransactionReceipt(txid))
+        if self.web3.eth.get_transaction_receipt(txid)['status'] == 0:
+            #print(self.web3.eth.get_transaction_receipt(txid))
             raise TransactionFailed
 
     def _block_timestamp(self):
@@ -190,7 +190,7 @@ class TestRealitio(TestCase):
             f.close()
 
         tx_hash = self.web3.eth.contract(abi=contract_if, bytecode=bcode).constructor().transact(self.deploy_tx)
-        addr = self.web3.eth.getTransactionReceipt(tx_hash).get('contractAddress')
+        addr = self.web3.eth.get_transaction_receipt(tx_hash).get('contractAddress')
         return self.web3.eth.contract(addr, abi=contract_if)
 
     def testS(self):
@@ -203,6 +203,7 @@ class TestRealitio(TestCase):
         prov = EthereumTesterProvider(EthereumTester(PyEVMBackend(genesis_params)))
 
         self.web3 = Web3(prov)
+        self.web3.strict_bytes_type_checking = False
         self.web3.testing.mine()
 
         k0 = self.web3.eth.accounts[0]
@@ -774,7 +775,7 @@ class TestRealitio(TestCase):
 
         self.raiseOnZeroStatus(txid)
 
-        #rcp = self.web3.eth.getTransactionReceipt(txid)
+        #rcp = self.web3.eth.get_transaction_receipt(txid)
         self._advance_clock(33)
         #time.sleep(10)
 
@@ -1257,7 +1258,7 @@ class TestRealitio(TestCase):
             0
             ,1100
         ).transact()
-        rcpt = self.web3.eth.getTransactionReceipt(txid)
+        rcpt = self.web3.eth.get_transaction_receipt(txid)
         gas_used = rcpt['cumulativeGasUsed']
         self.assertTrue(gas_used < 140000)
     
@@ -1267,7 +1268,7 @@ class TestRealitio(TestCase):
         txid = self.rc0.functions.submitAnswerERC20(self.question_id, to_answer_for_contract(12345), 0
         ,1
         ).transact()
-        rcpt = self.web3.eth.getTransactionReceipt(txid)
+        rcpt = self.web3.eth.get_transaction_receipt(txid)
 
         self.assertTrue(rcpt['cumulativeGasUsed'] < 140000)
 
@@ -1277,7 +1278,7 @@ class TestRealitio(TestCase):
         txid2 = self.rc0.functions.submitAnswerERC20(self.question_id, to_answer_for_contract(12346), 0
         ,2
         ).transact() 
-        rcpt = self.web3.eth.getTransactionReceipt(txid2)
+        rcpt = self.web3.eth.get_transaction_receipt(txid2)
         self.assertTrue(rcpt['cumulativeGasUsed'] < 80000)
 
     @unittest.skipIf(WORKING_ONLY, "Not under construction")
@@ -1321,7 +1322,7 @@ class TestRealitio(TestCase):
 
         start_arb_bal = self.token0.functions.balanceOf(self.arb0.address).call()
         txid = self.arb0.functions.callWithdraw().transact(self._txargs(sender=k7))
-        rcpt = self.web3.eth.getTransactionReceipt(txid)
+        rcpt = self.web3.eth.get_transaction_receipt(txid)
         end_arb_bal = self.token0.functions.balanceOf(self.arb0.address).call()
 
         self.assertEqual(end_arb_bal - start_arb_bal, 100 + (321*2))

package/tokens/ETH.json

@@ -2,15 +2,16 @@
     "decimals": 18,
     "small_number": 10000000000000000,
     "native_chains": {
-        "1": true,  
+        "1": true,
         "4": true,
         "5": true,
         "42": true,
         "280": true,
+        "300": true,
         "324": true,
         "1101": true,
         "534353": true,
         "1337702": true,
         "11155111": true
     }
-}
+}