@reality.eth/contracts 3.0.2 → 3.0.6

package/{development/contracts/Realitio_v2_1.sol → non_standard_deployments/zksync2/contracts/RealityETH_ERC20-3.0.sol}

@@ -2,11 +2,53 @@
 
 pragma solidity ^0.8.6;
 
-import './BalanceHolder.sol';
 
-// Next version of Realitio v2, will be deployed on xdai, may be deployed to other networks in future
-// API-compatible with Realitio v2, address will be stored in Realitio.json
-contract Realitio_v2_1 is BalanceHolder {
+/**
+ * @title ERC20 interface
+ * @dev see https://github.com/ethereum/EIPs/issues/20
+ */
+interface IERC20 {
+    function totalSupply() external view returns (uint256);
+
+    function balanceOf(address who) external view returns (uint256);
+
+    function allowance(address owner, address spender) external view returns (uint256);
+
+    function transfer(address to, uint256 value) external returns (bool);
+
+    function approve(address spender, uint256 value) external returns (bool);
+
+    function transferFrom(address from, address to, uint256 value) external returns (bool);
+
+    event Transfer(address indexed from, address indexed to, uint256 value);
+
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+}
+
+
+contract BalanceHolder {
+
+    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);
+    }
+
+}
+
+
+contract RealityETH_ERC20_v3_0 is BalanceHolder {
 
     address constant NULL_ADDRESS = address(0);
 
@@ -25,6 +67,10 @@ contract Realitio_v2_1 is BalanceHolder {
     // Proportion withheld when you claim an earlier bond.
     uint256 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 constant UNRESOLVED_ANSWER = 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe;
+
     event LogSetQuestionFee(
         address arbitrator,
         uint256 amount
@@ -49,6 +95,11 @@ contract Realitio_v2_1 is BalanceHolder {
         uint256 created
     );
 
+    event LogMinimumBond(
+        bytes32 indexed question_id,
+        uint256 min_bond
+    );
+
     event LogFundAnswerBounty(
         bytes32 indexed question_id,
         uint256 bounty_added,
@@ -95,6 +146,11 @@ contract Realitio_v2_1 is BalanceHolder {
         uint256 amount
     );
 
+    event LogReopenQuestion(
+        bytes32 indexed question_id,
+        bytes32 indexed reopened_question_id
+    );
+
     struct Question {
         bytes32 content_hash;
         address arbitrator;
@@ -106,6 +162,7 @@ contract Realitio_v2_1 is BalanceHolder {
         bytes32 best_answer;
         bytes32 history_hash;
         uint256 bond;
+        uint256 min_bond;
     }
 
     // Stored in a mapping indexed by commitment_id, a hash of commitment hash, question, bond. 
@@ -130,6 +187,9 @@ contract Realitio_v2_1 is BalanceHolder {
     mapping(bytes32 => Claim) public question_claims;
     mapping(bytes32 => Commitment) public commitments;
     mapping(address => uint256) public arbitrator_question_fees; 
+    mapping(bytes32 => bytes32) public reopened_questions;
+    mapping(bytes32 => bool) public reopener_questions;
+
 
     modifier onlyArbitrator(bytes32 question_id) {
         require(msg.sender == questions[question_id].arbitrator, "msg.sender must be arbitrator");
@@ -174,9 +234,14 @@ contract Realitio_v2_1 is BalanceHolder {
         _;
     }
 
-    modifier bondMustDouble(bytes32 question_id) {
-        require(msg.value > 0, "bond must be positive"); 
-        require(msg.value >= (questions[question_id].bond * 2), "bond must be double at least previous bond");
+    modifier bondMustDoubleAndMatchMinimum(bytes32 question_id, uint256 tokens) {
+        require(tokens > 0, "bond must be positive"); 
+        uint256 current_bond = questions[question_id].bond;
+        if (current_bond == 0) {
+            require(tokens >= (questions[question_id].min_bond), "bond must exceed the minimum");
+        } else {
+            require(tokens >= (current_bond * 2), "bond must be double at least previous bond");
+        }
         _;
     }
 
@@ -197,6 +262,16 @@ contract Realitio_v2_1 is BalanceHolder {
         createTemplate('{"title": "%s", "type": "datetime", "category": "%s", "lang": "%s"}');
     }
 
+    /// @notice Set the address of the ERC20 token that will be used for bonds.
+    /// @dev Should not be used with ERC20-like token contracts that implement callbacks like ERC777 that could cause re-entrancy issues
+    /// @param _token The ERC20 token that will be used for bonds.
+    function setToken(IERC20 _token) 
+    public
+    {
+        require(token == IERC20(address(0x0)), "Token can only be initialized once");
+        token = _token;
+    }
+
     /// @notice Function for arbitrator to set an optional per-question fee. 
     /// @dev The per-question fee, charged when a question is asked, is intended as an anti-spam measure.
     /// @param fee The fee to be charged by the arbitrator when a question is asked
@@ -216,7 +291,7 @@ contract Realitio_v2_1 is BalanceHolder {
         stateAny()
     public returns (uint256) {
         uint256 id = nextTemplateID;
-        templates[id] = block.number;
+        templates[id] = block.timestamp;
         template_hashes[id] = keccak256(abi.encodePacked(content));
         emit LogNewTemplate(id, msg.sender, content);
         nextTemplateID = id + 1;
@@ -237,13 +312,15 @@ contract Realitio_v2_1 is BalanceHolder {
         string memory question, address arbitrator, uint32 timeout, uint32 opening_ts, uint256 nonce 
     ) 
         // stateNotCreated is enforced by the internal _askQuestion
-    public payable returns (bytes32) {
+    public returns (bytes32) {
         uint256 template_id = createTemplate(content);
         return askQuestion(template_id, question, arbitrator, timeout, opening_ts, nonce);
     }
 
-    /// @notice Ask a new question and return the ID
+    /// @notice Ask a new question without a bounty and return the ID
     /// @dev Template data is only stored in the event logs, but its block number is kept in contract storage.
+    /// @dev Calling without the token param will only work if there is no arbitrator-set question fee.
+    /// @dev This has the same function signature as askQuestion() in the non-ERC20 version, which is optionally payable.
     /// @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
@@ -253,38 +330,121 @@ contract Realitio_v2_1 is BalanceHolder {
     /// @return The ID of the newly-created question, created deterministically.
     function askQuestion(uint256 template_id, string memory question, address arbitrator, uint32 timeout, uint32 opening_ts, uint256 nonce) 
         // stateNotCreated is enforced by the internal _askQuestion
-    public payable returns (bytes32) {
+    public returns (bytes32) {
+
+        require(templates[template_id] > 0, "template must exist");
+
+        bytes32 content_hash = keccak256(abi.encodePacked(template_id, opening_ts, question));
+        bytes32 question_id = keccak256(abi.encodePacked(content_hash, arbitrator, timeout, uint256(0), address(this), msg.sender, nonce));
+
+        // We emit this event here because _askQuestion doesn't need to know the unhashed question. Other events are emitted by _askQuestion.
+        emit LogNewQuestion(question_id, msg.sender, template_id, question, content_hash, arbitrator, timeout, opening_ts, nonce, block.timestamp);
+        _askQuestion(question_id, content_hash, arbitrator, timeout, opening_ts, 0, 0);
+
+        return question_id;
+    }
+
+    /// @notice Ask a new question with a bounty and return the ID
+    /// @dev Template data is only stored in the event logs, but its block number is kept in contract storage.
+    /// @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 tokens The combined initial question bounty and question fee
+    /// @return The ID of the newly-created question, created deterministically.
+    function askQuestionERC20(uint256 template_id, string memory question, address arbitrator, uint32 timeout, uint32 opening_ts, uint256 nonce, uint256 tokens) 
+        // stateNotCreated is enforced by the internal _askQuestion
+    public returns (bytes32) {
+
+        _deductTokensOrRevert(tokens);
+
+        require(templates[template_id] > 0, "template must exist");
+
+        bytes32 content_hash = keccak256(abi.encodePacked(template_id, opening_ts, question));
+        bytes32 question_id = keccak256(abi.encodePacked(content_hash, arbitrator, timeout, uint256(0), address(this), msg.sender, nonce));
+
+        // We emit this event here because _askQuestion doesn't need to know the unhashed question. Other events are emitted by _askQuestion.
+        emit LogNewQuestion(question_id, msg.sender, template_id, question, content_hash, arbitrator, timeout, opening_ts, nonce, block.timestamp);
+        _askQuestion(question_id, content_hash, arbitrator, timeout, opening_ts, 0, tokens);
+
+        return question_id;
+    }
+
+    /// @notice Ask a new question and return the ID
+    /// @dev Template data is only stored in the event logs, but its block number is kept in contract storage.
+    /// @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 may be used for an answer.
+    /// @param tokens Number of tokens sent
+    /// @return The ID of the newly-created question, created deterministically.
+    function askQuestionWithMinBondERC20(uint256 template_id, string memory question, address arbitrator, uint32 timeout, uint32 opening_ts, uint256 nonce, uint256 min_bond, uint256 tokens) 
+        // stateNotCreated is enforced by the internal _askQuestion
+    public returns (bytes32) {
+
+        _deductTokensOrRevert(tokens);
 
         require(templates[template_id] > 0, "template must exist");
 
         bytes32 content_hash = keccak256(abi.encodePacked(template_id, opening_ts, question));
-        bytes32 question_id = keccak256(abi.encodePacked(content_hash, arbitrator, timeout, msg.sender, nonce));
+        bytes32 question_id = keccak256(abi.encodePacked(content_hash, arbitrator, timeout, min_bond, address(this), msg.sender, nonce));
 
-        _askQuestion(question_id, content_hash, arbitrator, timeout, opening_ts);
+        // We emit this event here because _askQuestion doesn't need to know the unhashed question.
+        // Other events are emitted by _askQuestion.
         emit LogNewQuestion(question_id, msg.sender, template_id, question, content_hash, arbitrator, timeout, opening_ts, nonce, block.timestamp);
+        _askQuestion(question_id, content_hash, arbitrator, timeout, opening_ts, min_bond, tokens);
 
         return question_id;
     }
 
-    function _askQuestion(bytes32 question_id, bytes32 content_hash, address arbitrator, uint32 timeout, uint32 opening_ts) 
+    function _deductTokensOrRevert(uint256 tokens) 
+    internal {
+ 
+        if (tokens == 0) {
+            return;
+        }
+
+        uint256 bal = balanceOf[msg.sender];
+
+        // Deduct any tokens you have in your internal balance first
+        if (bal > 0) {
+            if (bal >= tokens) {
+                balanceOf[msg.sender] = bal - tokens;
+                return;
+            } else {
+                tokens = tokens - bal;
+                balanceOf[msg.sender] = 0;
+            }
+        }
+        // Now we need to charge the rest from 
+        require(token.transferFrom(msg.sender, address(this), tokens), "Transfer of tokens failed, insufficient approved balance?");
+        return;
+
+    }
+
+    function _askQuestion(bytes32 question_id, bytes32 content_hash, address arbitrator, uint32 timeout, uint32 opening_ts, uint256 min_bond, uint256 tokens) 
         stateNotCreated(question_id)
     internal {
 
         // A timeout of 0 makes no sense, and we will use this to check existence
         require(timeout > 0, "timeout must be positive"); 
         require(timeout < 365 days, "timeout must be less than 365 days"); 
-        require(arbitrator != NULL_ADDRESS, "arbitrator must be set");
 
-        uint256 bounty = msg.value;
+        uint256 bounty = tokens;
 
         // The arbitrator can set a fee for asking a question. 
         // This is intended as an anti-spam defence.
         // The fee is waived if the arbitrator is asking the question.
         // This allows them to set an impossibly high fee and make users proxy the question through them.
         // This would allow more sophisticated pricing, question whitelisting etc.
-        if (msg.sender != arbitrator) {
+        if (arbitrator != NULL_ADDRESS && msg.sender != arbitrator) {
             uint256 question_fee = arbitrator_question_fees[arbitrator];
-            require(bounty >= question_fee, "ETH provided must cover question fee"); 
+            require(bounty >= question_fee, "Tokens provided must cover question fee"); 
             bounty = bounty - question_fee;
             balanceOf[arbitrator] = balanceOf[arbitrator] + question_fee;
         }
@@ -293,18 +453,29 @@ contract Realitio_v2_1 is BalanceHolder {
         questions[question_id].arbitrator = arbitrator;
         questions[question_id].opening_ts = opening_ts;
         questions[question_id].timeout = timeout;
-        questions[question_id].bounty = bounty;
+
+        if (bounty > 0) {
+            questions[question_id].bounty = bounty;
+            emit LogFundAnswerBounty(question_id, bounty, bounty, msg.sender);
+        }
+
+        if (min_bond > 0) {
+            questions[question_id].min_bond = min_bond;
+            emit LogMinimumBond(question_id, min_bond);
+        }
 
     }
 
     /// @notice Add funds to the bounty for a question
     /// @dev Add bounty funds after the initial question creation. Can be done any time until the question is finalized.
     /// @param question_id The ID of the question you wish to fund
-    function fundAnswerBounty(bytes32 question_id) 
+    /// @param tokens The number of tokens to fund
+    function fundAnswerBountyERC20(bytes32 question_id, uint256 tokens) 
         stateOpen(question_id)
-    external payable {
-        questions[question_id].bounty = questions[question_id].bounty + msg.value;
-        emit LogFundAnswerBounty(question_id, msg.value, questions[question_id].bounty, msg.sender);
+    external {
+        _deductTokensOrRevert(tokens);
+        questions[question_id].bounty = questions[question_id].bounty + tokens;
+        emit LogFundAnswerBounty(question_id, tokens, questions[question_id].bounty, msg.sender);
     }
 
     /// @notice Submit an answer for a question.
@@ -313,13 +484,15 @@ contract Realitio_v2_1 is BalanceHolder {
     /// @param question_id The ID of the question
     /// @param answer The answer, encoded into bytes32
     /// @param max_previous If specified, reverts if a bond higher than this was submitted after you sent your transaction.
-    function submitAnswer(bytes32 question_id, bytes32 answer, uint256 max_previous) 
+    /// @param tokens The amount of tokens to submit
+    function submitAnswerERC20(bytes32 question_id, bytes32 answer, uint256 max_previous, uint256 tokens) 
         stateOpen(question_id)
-        bondMustDouble(question_id)
+        bondMustDoubleAndMatchMinimum(question_id, tokens)
         previousBondMustNotBeatMaxPrevious(question_id, max_previous)
-    external payable {
-        _addAnswerToHistory(question_id, answer, msg.sender, msg.value, false);
-        _updateCurrentAnswer(question_id, answer, questions[question_id].timeout);
+    external {
+        _deductTokensOrRevert(tokens);
+        _addAnswerToHistory(question_id, answer, msg.sender, tokens, false);
+        _updateCurrentAnswer(question_id, answer);
     }
 
     /// @notice Submit an answer for a question, crediting it to the specified account.
@@ -329,14 +502,16 @@ contract Realitio_v2_1 is BalanceHolder {
     /// @param answer The answer, encoded into bytes32
     /// @param max_previous If specified, reverts if a bond higher than this was submitted after you sent your transaction.
     /// @param answerer The account to which the answer should be credited
-    function submitAnswerFor(bytes32 question_id, bytes32 answer, uint256 max_previous, address answerer)
+    /// @param tokens Number of tokens sent
+    function submitAnswerForERC20(bytes32 question_id, bytes32 answer, uint256 max_previous, address answerer, uint256 tokens)
         stateOpen(question_id)
-        bondMustDouble(question_id)
+        bondMustDoubleAndMatchMinimum(question_id, tokens)
         previousBondMustNotBeatMaxPrevious(question_id, max_previous)
-    external payable {
+    external {
+        _deductTokensOrRevert(tokens);
         require(answerer != NULL_ADDRESS, "answerer must be non-zero");
-        _addAnswerToHistory(question_id, answer, answerer, msg.value, false);
-        _updateCurrentAnswer(question_id, answer, questions[question_id].timeout);
+        _addAnswerToHistory(question_id, answer, answerer, tokens, false);
+        _updateCurrentAnswer(question_id, answer);
     }
 
     // @notice Verify and store a commitment, including an appropriate timeout
@@ -359,17 +534,21 @@ contract Realitio_v2_1 is BalanceHolder {
     /// @param answer_hash The hash of your answer, plus a nonce that you will later reveal
     /// @param max_previous If specified, reverts if a bond higher than this was submitted after you sent your transaction.
     /// @param _answerer If specified, the address to be given as the question answerer. Defaults to the sender.
+    /// @param tokens Number of tokens sent
     /// @dev Specifying the answerer is useful if you want to delegate the commit-and-reveal to a third-party.
-    function submitAnswerCommitment(bytes32 question_id, bytes32 answer_hash, uint256 max_previous, address _answerer) 
+    function submitAnswerCommitmentERC20(bytes32 question_id, bytes32 answer_hash, uint256 max_previous, address _answerer, uint256 tokens) 
         stateOpen(question_id)
-        bondMustDouble(question_id)
+        bondMustDoubleAndMatchMinimum(question_id, tokens)
         previousBondMustNotBeatMaxPrevious(question_id, max_previous)
-    external payable {
+    external {
 
-        bytes32 commitment_id = keccak256(abi.encodePacked(question_id, answer_hash, msg.value));
+        _deductTokensOrRevert(tokens);
+
+        bytes32 commitment_id = keccak256(abi.encodePacked(question_id, answer_hash, tokens));
         address answerer = (_answerer == NULL_ADDRESS) ? msg.sender : _answerer;
+
         _storeCommitment(question_id, commitment_id);
-        _addAnswerToHistory(question_id, commitment_id, answerer, msg.value, true);
+        _addAnswerToHistory(question_id, commitment_id, answerer, tokens, true);
 
     }
 
@@ -397,7 +576,7 @@ contract Realitio_v2_1 is BalanceHolder {
         commitments[commitment_id].is_revealed = true;
 
         if (bond == questions[question_id].bond) {
-            _updateCurrentAnswer(question_id, answer, questions[question_id].timeout);
+            _updateCurrentAnswer(question_id, answer);
         }
 
         emit LogAnswerReveal(question_id, msg.sender, answer_hash, answer, nonce, bond);
@@ -418,10 +597,17 @@ contract Realitio_v2_1 is BalanceHolder {
         emit LogNewAnswer(answer_or_commitment_id, question_id, new_history_hash, answerer, bond, block.timestamp, is_commitment);
     }
 
-    function _updateCurrentAnswer(bytes32 question_id, bytes32 answer, uint32 timeout_secs)
+    function _updateCurrentAnswer(bytes32 question_id, bytes32 answer)
+    internal {
+        questions[question_id].best_answer = answer;
+        questions[question_id].finalize_ts = uint32(block.timestamp) + questions[question_id].timeout;
+    }
+
+    // Like _updateCurrentAnswer but without advancing the timeout
+    function _updateCurrentAnswerByArbitrator(bytes32 question_id, bytes32 answer)
     internal {
         questions[question_id].best_answer = answer;
-        questions[question_id].finalize_ts = uint32(block.timestamp) + timeout_secs;
+        questions[question_id].finalize_ts = uint32(block.timestamp);
     }
 
     /// @notice Notify the contract that the arbitrator has been paid for a question, freezing it pending their decision.
@@ -434,7 +620,7 @@ contract Realitio_v2_1 is BalanceHolder {
         stateOpen(question_id)
         previousBondMustNotBeatMaxPrevious(question_id, max_previous)
     external {
-        require(questions[question_id].bond > 0, "Question must already have an answer when arbitration is requested");
+        require(questions[question_id].finalize_ts > UNANSWERED, "Question must already have an answer when arbitration is requested");
         questions[question_id].is_pending_arbitration = true;
         emit LogNotifyOfArbitrationRequest(question_id, requester);
     }
@@ -469,8 +655,7 @@ contract Realitio_v2_1 is BalanceHolder {
 
         questions[question_id].is_pending_arbitration = false;
         _addAnswerToHistory(question_id, answer, answerer, 0, false);
-        _updateCurrentAnswer(question_id, answer, 0);
-
+        _updateCurrentAnswerByArbitrator(question_id, answer);
     }
 
     /// @notice Submit the answer for a question, for use by the arbitrator, working out the appropriate winner based on the last answer details.
@@ -521,10 +706,92 @@ contract Realitio_v2_1 is BalanceHolder {
     /// @return The answer formatted as a bytes32
     function resultFor(bytes32 question_id) 
         stateFinalized(question_id)
-    external view returns (bytes32) {
+    public view returns (bytes32) {
         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];
+            require(replacement_id != bytes32(0x0), "Question was settled too soon and has not been reopened");
+            // We only try one layer down rather than recursing to keep the gas costs predictable
+            result = resultFor(replacement_id);
+            require(result != UNRESOLVED_ANSWER, "Question replacement was settled too soon and has not been reopened");
+        }
+        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)
+        // stateNotCreated is enforced by the internal _askQuestion
+    public returns (bytes32) {
+
+        // _deductTokensOrRevert will be called when we call askQuestionWithMinBondERC20
+
+        require(isSettledTooSoon(reopens_question_id), "You can only reopen questions that resolved as settled too soon");
+
+        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
+        require(content_hash == questions[reopens_question_id].content_hash, "content hash mismatch");
+        require(arbitrator == questions[reopens_question_id].arbitrator, "arbitrator mismatch");
+        require(timeout == questions[reopens_question_id].timeout, "timeout mismatch");
+        require(opening_ts == questions[reopens_question_id].opening_ts , "opening_ts mismatch");
+        require(min_bond == questions[reopens_question_id].min_bond, "min_bond mismatch");
+
+        // 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.
+        require(!reopener_questions[reopens_question_id], "Question is already reopening a previous question");
+
+        // 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)) {
+            require(isSettledTooSoon(existing_reopen_question_id), "Question has already been reopened");
+            // 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.
@@ -677,8 +944,11 @@ contract Realitio_v2_1 is BalanceHolder {
                 // The entry is for the first payee we come to, ie the winner.
                 // They get the question bounty.
                 payee = addr;
-                queued_funds = queued_funds + questions[question_id].bounty;
-                questions[question_id].bounty = 0;
+
+                if (best_answer != UNRESOLVED_ANSWER && questions[question_id].bounty > 0) {
+                    _payPayee(question_id, payee, questions[question_id].bounty);
+                    questions[question_id].bounty = 0;
+                }
 
             } else if (addr != payee) {
 
@@ -816,4 +1086,11 @@ contract Realitio_v2_1 is BalanceHolder {
         return questions[question_id].bond;
     }
 
+    /// @notice Returns the minimum bond that can answer the question
+    /// @param question_id The ID of the question
+    function getMinBond(bytes32 question_id)
+    public view returns(uint256) {
+        return questions[question_id].min_bond;
+    }
+
 }

package/non_standard_deployments/zksync2/deploy/deploy.ts

@@ -0,0 +1,53 @@
+
+import { utils, Wallet } from "zksync-web3";
+import * as ethers from "ethers";
+import { HardhatRuntimeEnvironment } from "hardhat/types";
+import { Deployer } from "@matterlabs/hardhat-zksync-deploy";
+const fs = require('fs');
+
+// An example of a deploy script that will deploy and call a simple contract.
+export default async function (hre: HardhatRuntimeEnvironment) {
+  console.log(`Running deploy script for the reality.eth contract`);
+
+  const key_file = '/home/ed/secrets/zksync_goerli.sec';
+  const priv = fs.readFileSync(key_file, 'utf8').replace(/\n$/, "");
+
+  // Initialize the wallet.
+  const wallet = new Wallet(priv);
+
+  // Create deployer object and load the artifact of the contract we want to deploy.
+  const deployer = new Deployer(hre, wallet);
+  const artifact = await deployer.loadArtifact("RealityETH_ERC20_v3_0");
+
+  /*
+  // Deposit some funds to L2 in order to be able to perform L2 transactions.
+  const depositAmount = ethers.utils.parseEther("0.00001");
+  const depositHandle = await deployer.zkWallet.deposit({
+    to: deployer.zkWallet.address,
+    token: utils.ETH_ADDRESS,
+    amount: depositAmount,
+  });
+  // Wait until the deposit is processed on zkSync
+  await depositHandle.wait();
+ */
+
+  // Deploy this contract. The returned object will be of a `Contract` type, similarly to ones in `ethers`.
+  const realityContract = await deployer.deploy(artifact, []);
+
+  // Show the contract info.
+  const contractAddress = realityContract.address;
+  console.log(`${artifact.contractName} was deployed to ${contractAddress}`);
+
+  // Edit the greeting of the contract
+  const token = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE"
+  const setTokenHandle = await realityContract.setToken(token);
+  await setTokenHandle.wait();
+
+  const tokenFromContract = await realityContract.token();
+  if (tokenFromContract == token) {
+    console.log(`Contract greets us with ${token}!`);
+  } else {
+    console.error(`Contract said something unexpected: ${tokenFromContract}`);
+  }
+}
+

package/non_standard_deployments/zksync2/hardhat.config.ts

@@ -0,0 +1,30 @@
+require("@matterlabs/hardhat-zksync-deploy");
+require("@matterlabs/hardhat-zksync-solc");
+
+module.exports = {
+  zksolc: {
+    version: "0.1.0",
+    compilerSource: "docker",
+    settings: {
+      optimizer: {
+        enabled: true,
+      },
+      experimental: {
+        dockerImage: "matterlabs/zksolc",
+      },
+    },
+  },
+  zkSyncDeploy: {
+    zkSyncNetwork: "https://zksync2-testnet.zksync.dev",
+    ethNetwork: "goerli", // Can also be the RPC URL of the network (e.g. `https://goerli.infura.io/v3/<API_KEY>`)
+  },
+  networks: {
+    // To compile with zksolc, this must be the default network.
+    hardhat: {
+      zksync: true,
+    },
+  },
+  solidity: {
+    version: "0.8.10",
+  },
+};

package/non_standard_deployments/zksync2/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "zksync2",
+  "version": "1.0.0",
+  "main": "index.js",
+  "license": "MIT",
+  "devDependencies": {
+    "@matterlabs/hardhat-zksync-deploy": "^0.3.5",
+    "@matterlabs/hardhat-zksync-solc": "^0.3.5",
+    "ethers": "^5.6.9",
+    "hardhat": "^2.10.1",
+    "ts-node": "^10.9.1",
+    "typescript": "^4.7.4",
+    "zksync-web3": "^0.7.9"
+  }
+}