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

package/development/contracts/RealityETH-4.0.sol

@@ -3,10 +3,11 @@
 pragma solidity ^0.8.20;
 
 import {IRealityETHCore} from "./IRealityETHCore.sol";
+import {IRealityETHHistoryVerification} from "./IRealityETHHistoryVerification.sol";
 import {BalanceHolder} from "./BalanceHolder.sol";
 
 // solhint-disable-next-line contract-name-camelcase
-contract RealityETH_v4_0 is BalanceHolder, IRealityETHCore {
+contract RealityETH_v4_0 is BalanceHolder, IRealityETHCore, IRealityETHHistoryVerification {
     address private constant NULL_ADDRESS = address(0);
 
     // History hash when no history is created, or history has been cleared
@@ -18,18 +19,12 @@ contract RealityETH_v4_0 is BalanceHolder, IRealityETHCore {
     // 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();
@@ -376,7 +371,9 @@ contract RealityETH_v4_0 is BalanceHolder, IRealityETHCore {
     /// @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);
@@ -404,97 +401,6 @@ contract RealityETH_v4_0 is BalanceHolder, IRealityETHCore {
         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
-    /// @return The ID of the newly-created question, created deterministically.
-    function reopenQuestion(
-        uint256 template_id,
-        string memory question,
-        address arbitrator,
-        uint32 timeout,
-        uint32 opening_ts,
-        uint256 nonce,
-        uint256 min_bond,
-        bytes32 reopens_question_id
-    )
-        public
-        payable
-        returns (
-            // stateNotCreated is enforced by the internal _askQuestion
-            bytes32
-        )
-    {
-        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 = askQuestionWithMinBond(template_id, question, arbitrator, timeout, opening_ts, nonce, min_bond);
-
-        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
@@ -541,7 +447,9 @@ contract RealityETH_v4_0 is BalanceHolder, IRealityETHCore {
 
         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]);
@@ -581,10 +489,13 @@ contract RealityETH_v4_0 is BalanceHolder, IRealityETHCore {
         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) {
@@ -594,7 +505,7 @@ contract RealityETH_v4_0 is BalanceHolder, IRealityETHCore {
                 // 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;
                 }
@@ -662,6 +573,40 @@ contract RealityETH_v4_0 is BalanceHolder, IRealityETHCore {
         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/development/contracts/RealityETHReopenable-4.0.sol

@@ -0,0 +1,119 @@
+// SPDX-License-Identifier: GPL-3.0-only
+
+pragma solidity ^0.8.20;
+
+import {IRealityETHReopenable} from "./IRealityETHReopenable.sol";
+import {RealityETH_v4_0} from "./RealityETH-4.0.sol";
+
+/*
+* This version of reality.eth provides the ability to answer a question as "answered too soon", allowing it to be reopened.
+* This is useful when you want to ask a question but you don't know when the answer will be available.
+* You can set the settlement time at the earliest date it may be available, then if someone answers it too soon, it can be answered at such then later reopened.
+* NB In v3 of reality.eth this feature was built in and there was no way to turn it off. 
+* From v4, we ship two versions: RealityETH without it, and RealityETHReopenable with it.
+*/
+
+// solhint-disable-next-line contract-name-camelcase
+contract RealityETHReopenable_v4_0 is IRealityETHReopenable, RealityETH_v4_0 {
+    // 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;
+
+    mapping(bytes32 => bytes32) public reopened_questions;
+    mapping(bytes32 => bool) public reopener_questions;
+
+    function _isBountyPayableOnAnswer(bytes32 answer) internal pure override returns (bool) {
+        return (answer != UNRESOLVED_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
+    /// @return The ID of the newly-created question, created deterministically.
+    function reopenQuestion(
+        uint256 template_id,
+        string memory question,
+        address arbitrator,
+        uint32 timeout,
+        uint32 opening_ts,
+        uint256 nonce,
+        uint256 min_bond,
+        bytes32 reopens_question_id
+    )
+        public
+        payable
+        returns (
+            // stateNotCreated is enforced by the internal _askQuestion
+            bytes32
+        )
+    {
+        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 = askQuestionWithMinBond(template_id, question, arbitrator, timeout, opening_ts, nonce, min_bond);
+
+        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;
+    }
+}

package/development/contracts/RealityETHReopenable_ERC20-4.0.sol

@@ -0,0 +1,122 @@
+// SPDX-License-Identifier: GPL-3.0-only
+
+pragma solidity ^0.8.20;
+
+import {IRealityETHReopenable_ERC20} from "./IRealityETHReopenable_ERC20.sol";
+import {RealityETH_ERC20_v4_0} from "./RealityETH_ERC20-4.0.sol";
+
+/*
+* This version of reality.eth provides the ability to answer a question as "answered too soon", allowing it to be reopened.
+* This is useful when you want to ask a question but you don't know when the answer will be available.
+* You can set the settlement time at the earliest date it may be available, then if someone answers it too soon, it can be answered at such then later reopened.
+* NB In v3 of reality.eth this feature was built in and there was no way to turn it off.
+* From v4, we ship two versions: RealityETH_ERC20 without it, and RealityETHReopenable_ERC20 with it.
+*/
+
+// solhint-disable-next-line contract-name-camelcase
+contract RealityETHReopenable_v4_0 is IRealityETHReopenable_ERC20, RealityETH_ERC20_v4_0 {
+    // 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;
+
+    mapping(bytes32 => bytes32) public reopened_questions;
+    mapping(bytes32 => bool) public reopener_questions;
+
+    function _isBountyPayableOnAnswer(bytes32 answer) internal pure override returns (bool) {
+        return (answer != UNRESOLVED_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;
+    }
+}