@reality.eth/contracts 3.0.46 → 3.0.47

package/development/contracts/{RealityETH_ERC20-3.0.sol → RealityETH_ERC20-4.0.sol}

@@ -1,154 +1,39 @@
 // SPDX-License-Identifier: GPL-3.0-only
 
-pragma solidity ^0.8.10;
+pragma solidity ^0.8.20;
 
-import './BalanceHolder_ERC20.sol';
+import {IERC20} from "./IERC20.sol";
+import {IRealityETHCore_ERC20} from "./IRealityETHCore_ERC20.sol";
+import {BalanceHolder_ERC20} from "./BalanceHolder_ERC20.sol";
 
-contract RealityETH_ERC20_v3_0 is BalanceHolder_ERC20 {
-
-    address constant NULL_ADDRESS = address(0);
+// solhint-disable-next-line contract-name-camelcase
+contract RealityETH_ERC20_v4_0 is BalanceHolder_ERC20, IRealityETHCore_ERC20 {
+    address private constant NULL_ADDRESS = address(0);
 
     // History hash when no history is created, or history has been cleared
-    bytes32 constant NULL_HASH = bytes32(0);
+    bytes32 private constant NULL_HASH = bytes32(0);
 
     // An unitinalized finalize_ts for a question will indicate an unanswered question.
-    uint32 constant UNANSWERED = 0;
-
-    // An unanswered reveal_ts for a commitment will indicate that it does not exist.
-    uint256 constant COMMITMENT_NON_EXISTENT = 0;
-
-    // Commit->reveal timeout is 1/8 of the question timeout (rounded down).
-    uint32 constant COMMITMENT_TIMEOUT_RATIO = 8;
+    uint32 private constant UNANSWERED = 0;
 
     // Proportion withheld when you claim an earlier bond.
-    uint256 constant BOND_CLAIM_FEE_PROPORTION = 40; // One 40th ie 2.5%
+    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 constant UNRESOLVED_ANSWER = 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe;
-
-    event LogSetQuestionFee(
-        address arbitrator,
-        uint256 amount
-    );
-
-    event LogNewTemplate(
-        uint256 indexed template_id,
-        address indexed user, 
-        string question_text
-    );
-
-    event LogNewQuestion(
-        bytes32 indexed question_id,
-        address indexed user, 
-        uint256 template_id,
-        string question,
-        bytes32 indexed content_hash,
-        address arbitrator, 
-        uint32 timeout,
-        uint32 opening_ts,
-        uint256 nonce,
-        uint256 created
-    );
-
-    event LogMinimumBond(
-        bytes32 indexed question_id,
-        uint256 min_bond
-    );
-
-    event LogFundAnswerBounty(
-        bytes32 indexed question_id,
-        uint256 bounty_added,
-        uint256 bounty,
-        address indexed user 
-    );
-
-    event LogNewAnswer(
-        bytes32 answer,
-        bytes32 indexed question_id,
-        bytes32 history_hash,
-        address indexed user,
-        uint256 bond,
-        uint256 ts,
-        bool is_commitment
-    );
-
-    event LogAnswerReveal(
-        bytes32 indexed question_id, 
-        address indexed user, 
-        bytes32 indexed answer_hash, 
-        bytes32 answer, 
-        uint256 nonce, 
-        uint256 bond
-    );
-
-    event LogNotifyOfArbitrationRequest(
-        bytes32 indexed question_id,
-        address indexed user 
-    );
-
-    event LogCancelArbitration(
-        bytes32 indexed question_id
-    );
-
-    event LogFinalize(
-        bytes32 indexed question_id,
-        bytes32 indexed answer
-    );
-
-    event LogClaim(
-        bytes32 indexed question_id,
-        address indexed user,
-        uint256 amount
-    );
-
-    event LogReopenQuestion(
-        bytes32 indexed question_id,
-        bytes32 indexed reopened_question_id
-    );
-
-    struct Question {
-        bytes32 content_hash;
-        address arbitrator;
-        uint32 opening_ts;
-        uint32 timeout;
-        uint32 finalize_ts;
-        bool is_pending_arbitration;
-        uint256 bounty;
-        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. 
-    struct Commitment {
-        uint32 reveal_ts;
-        bool is_revealed;
-        bytes32 revealed_answer;
-    }
-
-    // Only used when claiming more bonds than fits into a transaction
-    // Stored in a mapping indexed by question_id.
-    struct Claim {
-        address payee;
-        uint256 last_bond;
-        uint256 queued_funds;
-    }
+    bytes32 private constant UNRESOLVED_ANSWER = 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe;
 
-    uint256 nextTemplateID = 0;
+    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(bytes32 => Commitment) public commitments;
-    mapping(address => uint256) public arbitrator_question_fees; 
+    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");
+        if (msg.sender != questions[question_id].arbitrator) revert MsgSenderMustBeArbitrator();
         _;
     }
 
@@ -157,57 +42,58 @@ contract RealityETH_ERC20_v3_0 is BalanceHolder_ERC20 {
     }
 
     modifier stateNotCreated(bytes32 question_id) {
-        require(questions[question_id].timeout == 0, "question must not exist");
+        if (questions[question_id].timeout != 0) revert QuestionMustNotExist();
         _;
     }
 
     modifier stateOpen(bytes32 question_id) {
-        require(questions[question_id].timeout > 0, "question must exist");
-        require(!questions[question_id].is_pending_arbitration, "question must not be pending arbitration");
+        if (questions[question_id].timeout == 0) revert QuestionMustExist();
+        if (questions[question_id].is_pending_arbitration) revert QuestionMustNotBePendingArbitration();
         uint32 finalize_ts = questions[question_id].finalize_ts;
-        require(finalize_ts == UNANSWERED || finalize_ts > uint32(block.timestamp), "finalization deadline must not have passed");
+        if (finalize_ts != UNANSWERED && finalize_ts <= uint32(block.timestamp)) revert FinalizationDeadlineMustNotHavePassed();
         uint32 opening_ts = questions[question_id].opening_ts;
-        require(opening_ts == 0 || opening_ts <= uint32(block.timestamp), "opening date must have passed"); 
+        if (opening_ts != 0 && opening_ts > uint32(block.timestamp)) revert OpeningDateMustHavePassed();
         _;
     }
 
     modifier statePendingArbitration(bytes32 question_id) {
-        require(questions[question_id].is_pending_arbitration, "question must be pending arbitration");
+        if (!questions[question_id].is_pending_arbitration) revert QuestionMustBePendingArbitration();
         _;
     }
 
     modifier stateOpenOrPendingArbitration(bytes32 question_id) {
-        require(questions[question_id].timeout > 0, "question must exist");
+        if (questions[question_id].timeout == 0) revert QuestionMustExist();
         uint32 finalize_ts = questions[question_id].finalize_ts;
-        require(finalize_ts == UNANSWERED || finalize_ts > uint32(block.timestamp), "finalization dealine must not have passed");
+        if (finalize_ts != UNANSWERED && finalize_ts <= uint32(block.timestamp)) revert FinalizationDealineMustNotHavePassed();
         uint32 opening_ts = questions[question_id].opening_ts;
-        require(opening_ts == 0 || opening_ts <= uint32(block.timestamp), "opening date must have passed"); 
+        if (opening_ts != 0 && opening_ts > uint32(block.timestamp)) revert OpeningDateMustHavePassed();
         _;
     }
 
     modifier stateFinalized(bytes32 question_id) {
-        require(isFinalized(question_id), "question must be finalized");
+        if (!isFinalized(question_id)) revert QuestionMustBeFinalized();
         _;
     }
 
     modifier bondMustDoubleAndMatchMinimum(bytes32 question_id, uint256 tokens) {
-        require(tokens > 0, "bond must be positive"); 
+        if (tokens == 0) revert BondMustBePositive();
         uint256 current_bond = questions[question_id].bond;
         if (current_bond == 0) {
-            require(tokens >= (questions[question_id].min_bond), "bond must exceed the minimum");
+            if (tokens < (questions[question_id].min_bond)) revert BondMustExceedTheMinimum();
         } else {
-            require(tokens >= (current_bond * 2), "bond must be double at least previous bond");
+            if (tokens < (current_bond * 2)) revert BondMustBeDoubleAtLeastPreviousBond();
         }
         _;
     }
 
     modifier previousBondMustNotBeatMaxPrevious(bytes32 question_id, uint256 max_previous) {
         if (max_previous > 0) {
-            require(questions[question_id].bond <= max_previous, "bond must exceed max_previous");
+            if (questions[question_id].bond > max_previous) revert BondMustExceedMax_Previous();
         }
         _;
     }
 
+    /* solhint-disable quotes */
     /// @notice Constructor, sets up some initial templates
     /// @dev Creates some generalized templates for different question types used in the DApp.
     constructor() {
@@ -217,23 +103,20 @@ contract RealityETH_ERC20_v3_0 is BalanceHolder_ERC20 {
         createTemplate('{"title": "%s", "type": "multiple-select", "outcomes": [%s], "category": "%s", "lang": "%s"}');
         createTemplate('{"title": "%s", "type": "datetime", "category": "%s", "lang": "%s"}');
     }
+    /* solhint-enable quotes */
 
     /// @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");
+    function setToken(IERC20 _token) public {
+        if (token != IERC20(address(0x0))) revert TokenCanOnlyBeInitializedOnce();
         token = _token;
     }
 
-    /// @notice Function for arbitrator to set an optional per-question fee. 
+    /// @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
-    function setQuestionFee(uint256 fee) 
-        stateAny() 
-    external {
+    function setQuestionFee(uint256 fee) external stateAny {
         arbitrator_question_fees[msg.sender] = fee;
         emit LogSetQuestionFee(msg.sender, fee);
     }
@@ -243,9 +126,7 @@ contract RealityETH_ERC20_v3_0 is BalanceHolder_ERC20 {
     /// @dev Template data is only stored in the event logs, but its block number is kept in contract storage.
     /// @param content The template content
     /// @return The ID of the newly-created template, which is created sequentially.
-    function createTemplate(string memory content) 
-        stateAny()
-    public returns (uint256) {
+    function createTemplate(string memory content) public stateAny returns (uint256) {
         uint256 id = nextTemplateID;
         templates[id] = block.number;
         template_hashes[id] = keccak256(abi.encodePacked(content));
@@ -264,11 +145,19 @@ contract RealityETH_ERC20_v3_0 is BalanceHolder_ERC20 {
     /// @param nonce A user-specified nonce used in the question ID. Change it to repeat a question.
     /// @return The ID of the newly-created template, which is created sequentially.
     function createTemplateAndAskQuestion(
-        string memory content, 
-        string memory question, address arbitrator, uint32 timeout, uint32 opening_ts, uint256 nonce 
-    ) 
-        // stateNotCreated is enforced by the internal _askQuestion
-    public returns (bytes32) {
+        string memory content,
+        string memory question,
+        address arbitrator,
+        uint32 timeout,
+        uint32 opening_ts,
+        uint256 nonce
+    )
+        public
+        returns (
+            // stateNotCreated is enforced by the internal _askQuestion
+            bytes32
+        )
+    {
         uint256 template_id = createTemplate(content);
         return askQuestion(template_id, question, arbitrator, timeout, opening_ts, nonce);
     }
@@ -284,11 +173,21 @@ contract RealityETH_ERC20_v3_0 is BalanceHolder_ERC20 {
     /// @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.
     /// @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 returns (bytes32) {
-
-        require(templates[template_id] > 0, "template must exist");
+    function askQuestion(
+        uint256 template_id,
+        string memory question,
+        address arbitrator,
+        uint32 timeout,
+        uint32 opening_ts,
+        uint256 nonce
+    )
+        public
+        returns (
+            // stateNotCreated is enforced by the internal _askQuestion
+            bytes32
+        )
+    {
+        if (templates[template_id] == 0) revert TemplateMustExist();
 
         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));
@@ -310,13 +209,24 @@ contract RealityETH_ERC20_v3_0 is BalanceHolder_ERC20 {
     /// @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) {
-
+    function askQuestionERC20(
+        uint256 template_id,
+        string memory question,
+        address arbitrator,
+        uint32 timeout,
+        uint32 opening_ts,
+        uint256 nonce,
+        uint256 tokens
+    )
+        public
+        returns (
+            // stateNotCreated is enforced by the internal _askQuestion
+            bytes32
+        )
+    {
         _deductTokensOrRevert(tokens);
 
-        require(templates[template_id] > 0, "template must exist");
+        if (templates[template_id] == 0) revert TemplateMustExist();
 
         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));
@@ -339,13 +249,25 @@ contract RealityETH_ERC20_v3_0 is BalanceHolder_ERC20 {
     /// @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) {
-
+    function askQuestionWithMinBondERC20(
+        uint256 template_id,
+        string memory question,
+        address arbitrator,
+        uint32 timeout,
+        uint32 opening_ts,
+        uint256 nonce,
+        uint256 min_bond,
+        uint256 tokens
+    )
+        public
+        returns (
+            // stateNotCreated is enforced by the internal _askQuestion
+            bytes32
+        )
+    {
         _deductTokensOrRevert(tokens);
 
-        require(templates[template_id] > 0, "template must exist");
+        if (templates[template_id] == 0) revert TemplateMustExist();
 
         bytes32 content_hash = keccak256(abi.encodePacked(template_id, opening_ts, question));
         bytes32 question_id = keccak256(abi.encodePacked(content_hash, arbitrator, timeout, min_bond, address(this), msg.sender, nonce));
@@ -358,9 +280,7 @@ contract RealityETH_ERC20_v3_0 is BalanceHolder_ERC20 {
         return question_id;
     }
 
-    function _deductTokensOrRevert(uint256 tokens) 
-    internal {
- 
+    function _deductTokensOrRevert(uint256 tokens) internal {
         if (tokens == 0) {
             return;
         }
@@ -377,30 +297,26 @@ contract RealityETH_ERC20_v3_0 is BalanceHolder_ERC20 {
                 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?");
+        // Now we need to charge the rest from
+        if (!token.transferFrom(msg.sender, address(this), tokens)) revert TransferOfTokensFailedInsufficientApprovedBalance();
         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 {
-
+    function _askQuestion(bytes32 question_id, bytes32 content_hash, address arbitrator, uint32 timeout, uint32 opening_ts, uint256 min_bond, uint256 tokens) internal stateNotCreated(question_id) {
         // 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"); 
+        if (timeout == 0) revert TimeoutMustBePositive();
+        if (timeout >= 365 days) revert TimeoutMustBeLessThan365Days();
 
         uint256 bounty = tokens;
 
-        // The arbitrator can set a fee for asking a question. 
+        // 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 (arbitrator != NULL_ADDRESS && msg.sender != arbitrator) {
             uint256 question_fee = arbitrator_question_fees[arbitrator];
-            require(bounty >= question_fee, "Tokens provided must cover question fee"); 
+            if (bounty < question_fee) revert TokensProvidedMustCoverQuestionFee();
             bounty = bounty - question_fee;
             balanceOf[arbitrator] = balanceOf[arbitrator] + question_fee;
         }
@@ -419,16 +335,13 @@ contract RealityETH_ERC20_v3_0 is BalanceHolder_ERC20 {
             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
     /// @param tokens The number of tokens to fund
-    function fundAnswerBountyERC20(bytes32 question_id, uint256 tokens) 
-        stateOpen(question_id)
-    external {
+    function fundAnswerBountyERC20(bytes32 question_id, uint256 tokens) external stateOpen(question_id) {
         _deductTokensOrRevert(tokens);
         questions[question_id].bounty = questions[question_id].bounty + tokens;
         emit LogFundAnswerBounty(question_id, tokens, questions[question_id].bounty, msg.sender);
@@ -436,113 +349,43 @@ contract RealityETH_ERC20_v3_0 is BalanceHolder_ERC20 {
 
     /// @notice Submit an answer for a question.
     /// @dev Adds the answer to the history and updates the current "best" answer.
-    /// May be subject to front-running attacks; Substitute submitAnswerCommitment()->submitAnswerReveal() to prevent them.
     /// @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.
     /// @param tokens The amount of tokens to submit
-    function submitAnswerERC20(bytes32 question_id, bytes32 answer, uint256 max_previous, uint256 tokens) 
-        stateOpen(question_id)
-        bondMustDoubleAndMatchMinimum(question_id, tokens)
-        previousBondMustNotBeatMaxPrevious(question_id, max_previous)
-    external {
+    function submitAnswerERC20(
+        bytes32 question_id,
+        bytes32 answer,
+        uint256 max_previous,
+        uint256 tokens
+    ) external stateOpen(question_id) bondMustDoubleAndMatchMinimum(question_id, tokens) previousBondMustNotBeatMaxPrevious(question_id, max_previous) {
         _deductTokensOrRevert(tokens);
-        _addAnswerToHistory(question_id, answer, msg.sender, tokens, false);
+        _addAnswerToHistory(question_id, answer, msg.sender, tokens);
         _updateCurrentAnswer(question_id, answer);
     }
 
     /// @notice Submit an answer for a question, crediting it to the specified account.
     /// @dev Adds the answer to the history and updates the current "best" answer.
-    /// May be subject to front-running attacks; Substitute submitAnswerCommitment()->submitAnswerReveal() to prevent them.
     /// @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.
     /// @param answerer The account to which the answer should be credited
     /// @param tokens Number of tokens sent
-    function submitAnswerForERC20(bytes32 question_id, bytes32 answer, uint256 max_previous, address answerer, uint256 tokens)
-        stateOpen(question_id)
-        bondMustDoubleAndMatchMinimum(question_id, tokens)
-        previousBondMustNotBeatMaxPrevious(question_id, max_previous)
-    external {
+    function submitAnswerForERC20(
+        bytes32 question_id,
+        bytes32 answer,
+        uint256 max_previous,
+        address answerer,
+        uint256 tokens
+    ) external stateOpen(question_id) bondMustDoubleAndMatchMinimum(question_id, tokens) previousBondMustNotBeatMaxPrevious(question_id, max_previous) {
         _deductTokensOrRevert(tokens);
-        require(answerer != NULL_ADDRESS, "answerer must be non-zero");
-        _addAnswerToHistory(question_id, answer, answerer, tokens, false);
+        if (answerer == NULL_ADDRESS) revert AnswererMustBeNonZero();
+        _addAnswerToHistory(question_id, answer, answerer, tokens);
         _updateCurrentAnswer(question_id, answer);
     }
 
-    // @notice Verify and store a commitment, including an appropriate timeout
-    // @param question_id The ID of the question to store
-    // @param commitment The ID of the commitment
-    function _storeCommitment(bytes32 question_id, bytes32 commitment_id) 
-    internal
-    {
-        require(commitments[commitment_id].reveal_ts == COMMITMENT_NON_EXISTENT, "commitment must not already exist");
-
-        uint32 commitment_timeout = questions[question_id].timeout / COMMITMENT_TIMEOUT_RATIO;
-        commitments[commitment_id].reveal_ts = uint32(block.timestamp) + commitment_timeout;
-    }
-
-    /// @notice Submit the hash of an answer, laying your claim to that answer if you reveal it in a subsequent transaction.
-    /// @dev Creates a hash, commitment_id, uniquely identifying this answer, to this question, with this bond.
-    /// The commitment_id is stored in the answer history where the answer would normally go.
-    /// Does not update the current best answer - this is left to the later submitAnswerReveal() transaction.
-    /// @param question_id The ID of the question
-    /// @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 submitAnswerCommitmentERC20(bytes32 question_id, bytes32 answer_hash, uint256 max_previous, address _answerer, uint256 tokens) 
-        stateOpen(question_id)
-        bondMustDoubleAndMatchMinimum(question_id, tokens)
-        previousBondMustNotBeatMaxPrevious(question_id, max_previous)
-    external {
-
-        _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, tokens, true);
-
-    }
-
-    /// @notice Submit the answer whose hash you sent in a previous submitAnswerCommitment() transaction
-    /// @dev Checks the parameters supplied recreate an existing commitment, and stores the revealed answer
-    /// Updates the current answer unless someone has since supplied a new answer with a higher bond
-    /// msg.sender is intentionally not restricted to the user who originally sent the commitment; 
-    /// For example, the user may want to provide the answer+nonce to a third-party service and let them send the tx
-    /// NB If we are pending arbitration, it will be up to the arbitrator to wait and see any outstanding reveal is sent
-    /// @param question_id The ID of the question
-    /// @param answer The answer, encoded as bytes32
-    /// @param nonce The nonce that, combined with the answer, recreates the answer_hash you gave in submitAnswerCommitment()
-    /// @param bond The bond that you paid in your submitAnswerCommitment() transaction
-    function submitAnswerReveal(bytes32 question_id, bytes32 answer, uint256 nonce, uint256 bond) 
-        stateOpenOrPendingArbitration(question_id)
-    external {
-
-        bytes32 answer_hash = keccak256(abi.encodePacked(answer, nonce));
-        bytes32 commitment_id = keccak256(abi.encodePacked(question_id, answer_hash, bond));
-
-        require(!commitments[commitment_id].is_revealed, "commitment must not have been revealed yet");
-        require(commitments[commitment_id].reveal_ts > uint32(block.timestamp), "reveal deadline must not have passed");
-
-        commitments[commitment_id].revealed_answer = answer;
-        commitments[commitment_id].is_revealed = true;
-
-        if (bond == questions[question_id].bond) {
-            _updateCurrentAnswer(question_id, answer);
-        }
-
-        emit LogAnswerReveal(question_id, msg.sender, answer_hash, answer, nonce, bond);
-
-    }
-
-    function _addAnswerToHistory(bytes32 question_id, bytes32 answer_or_commitment_id, address answerer, uint256 bond, bool is_commitment) 
-    internal 
-    {
-        bytes32 new_history_hash = keccak256(abi.encodePacked(questions[question_id].history_hash, answer_or_commitment_id, bond, answerer, is_commitment));
+    function _addAnswerToHistory(bytes32 question_id, bytes32 answer, address answerer, uint256 bond) internal {
+        bytes32 new_history_hash = keccak256(abi.encodePacked(questions[question_id].history_hash, answer, bond, answerer, false));
 
         // Update the current bond level, if there's a bond (ie anything except arbitration)
         if (bond > 0) {
@@ -550,18 +393,16 @@ contract RealityETH_ERC20_v3_0 is BalanceHolder_ERC20 {
         }
         questions[question_id].history_hash = new_history_hash;
 
-        emit LogNewAnswer(answer_or_commitment_id, question_id, new_history_hash, answerer, bond, block.timestamp, is_commitment);
+        emit LogNewAnswer(answer, question_id, new_history_hash, answerer, bond, block.timestamp, false);
     }
 
-    function _updateCurrentAnswer(bytes32 question_id, bytes32 answer)
-    internal {
+    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 {
+    function _updateCurrentAnswerByArbitrator(bytes32 question_id, bytes32 answer) internal {
         questions[question_id].best_answer = answer;
         questions[question_id].finalize_ts = uint32(block.timestamp);
     }
@@ -571,12 +412,12 @@ contract RealityETH_ERC20_v3_0 is BalanceHolder_ERC20 {
     /// @param question_id The ID of the question
     /// @param requester The account that requested arbitration
     /// @param max_previous If specified, reverts if a bond higher than this was submitted after you sent your transaction.
-    function notifyOfArbitrationRequest(bytes32 question_id, address requester, uint256 max_previous) 
-        onlyArbitrator(question_id)
-        stateOpen(question_id)
-        previousBondMustNotBeatMaxPrevious(question_id, max_previous)
-    external {
-        require(questions[question_id].finalize_ts > UNANSWERED, "Question must already have an answer when arbitration is requested");
+    function notifyOfArbitrationRequest(
+        bytes32 question_id,
+        address requester,
+        uint256 max_previous
+    ) external onlyArbitrator(question_id) stateOpen(question_id) previousBondMustNotBeatMaxPrevious(question_id, max_previous) {
+        if (questions[question_id].finalize_ts <= UNANSWERED) revert QuestionMustAlreadyHaveAnAnswerWhenArbitrationIsRequested();
         questions[question_id].is_pending_arbitration = true;
         emit LogNotifyOfArbitrationRequest(question_id, requester);
     }
@@ -584,10 +425,7 @@ contract RealityETH_ERC20_v3_0 is BalanceHolder_ERC20 {
     /// @notice Cancel a previously-requested arbitration and extend the timeout
     /// @dev Useful when doing arbitration across chains that can't be requested atomically
     /// @param question_id The ID of the question
-    function cancelArbitration(bytes32 question_id) 
-        onlyArbitrator(question_id)
-        statePendingArbitration(question_id)
-    external {
+    function cancelArbitration(bytes32 question_id) external onlyArbitrator(question_id) statePendingArbitration(question_id) {
         questions[question_id].is_pending_arbitration = false;
         questions[question_id].finalize_ts = uint32(block.timestamp) + questions[question_id].timeout;
         emit LogCancelArbitration(question_id);
@@ -601,16 +439,12 @@ contract RealityETH_ERC20_v3_0 is BalanceHolder_ERC20 {
     /// @param question_id The ID of the question
     /// @param answer The answer, encoded into bytes32
     /// @param answerer The account credited with this answer for the purpose of bond claims
-    function submitAnswerByArbitrator(bytes32 question_id, bytes32 answer, address answerer) 
-        onlyArbitrator(question_id)
-        statePendingArbitration(question_id)
-    public {
-
-        require(answerer != NULL_ADDRESS, "answerer must be provided");
+    function submitAnswerByArbitrator(bytes32 question_id, bytes32 answer, address answerer) public onlyArbitrator(question_id) statePendingArbitration(question_id) {
+        if (answerer == NULL_ADDRESS) revert AnswererMustBeProvided();
         emit LogFinalize(question_id, answer);
 
         questions[question_id].is_pending_arbitration = false;
-        _addAnswerToHistory(question_id, answer, answerer, 0, false);
+        _addAnswerToHistory(question_id, answer, answerer, 0);
         _updateCurrentAnswerByArbitrator(question_id, answer);
     }
 
@@ -620,71 +454,54 @@ contract RealityETH_ERC20_v3_0 is BalanceHolder_ERC20 {
     /// @param answer The answer, encoded into bytes32
     /// @param payee_if_wrong The account to by credited as winner if the last answer given is wrong, usually the account that paid the arbitrator
     /// @param last_history_hash The history hash before the final one
-    /// @param last_answer_or_commitment_id The last answer given, or the commitment ID if it was a commitment.
+    /// @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_or_commitment_id, address last_answerer) 
-    external {
-        bool is_commitment = _verifyHistoryInputOrRevert(questions[question_id].history_hash, last_history_hash, last_answer_or_commitment_id, questions[question_id].bond, last_answerer);
-
-        address payee;
-        // If the last answer is an unrevealed commit, it's always wrong.
-        // For anything else, the last answer was set as the "best answer" in submitAnswer or submitAnswerReveal.
-        if (is_commitment && !commitments[last_answer_or_commitment_id].is_revealed) {
-            require(commitments[last_answer_or_commitment_id].reveal_ts < uint32(block.timestamp), "You must wait for the reveal deadline before finalizing");
-            payee = payee_if_wrong;
-        } else {
-            payee = (questions[question_id].best_answer == answer) ? last_answerer : payee_if_wrong;
-        }
+    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);
+
+        address payee = (questions[question_id].best_answer == answer) ? last_answerer : payee_if_wrong;
         submitAnswerByArbitrator(question_id, answer, payee);
     }
 
-
     /// @notice Report whether the answer to the specified question is finalized
     /// @param question_id The ID of the question
     /// @return Return true if finalized
-    function isFinalized(bytes32 question_id) 
-    view public returns (bool) {
+    function isFinalized(bytes32 question_id) public view returns (bool) {
         uint32 finalize_ts = questions[question_id].finalize_ts;
-        return ( !questions[question_id].is_pending_arbitration && (finalize_ts > UNANSWERED) && (finalize_ts <= uint32(block.timestamp)) );
+        return (!questions[question_id].is_pending_arbitration && (finalize_ts > UNANSWERED) && (finalize_ts <= uint32(block.timestamp)));
     }
 
     /// @notice (Deprecated) Return the final answer to the specified question, or revert if there isn't one
     /// @param question_id The ID of the question
     /// @return The answer formatted as a bytes32
-    function getFinalAnswer(bytes32 question_id) 
-        stateFinalized(question_id)
-    external view returns (bytes32) {
+    function getFinalAnswer(bytes32 question_id) external view stateFinalized(question_id) returns (bytes32) {
         return questions[question_id].best_answer;
     }
 
     /// @notice Return the final answer to the specified question, or revert if there isn't one
     /// @param question_id The ID of the question
     /// @return The answer formatted as a bytes32
-    function resultFor(bytes32 question_id) 
-        stateFinalized(question_id)
-    public view returns (bytes32) {
+    function resultFor(bytes32 question_id) public view stateFinalized(question_id) 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) {
+    /// @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) {
+    /// @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");
+            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);
-            require(result != UNRESOLVED_ANSWER, "Question replacement was settled too soon and has not been reopened");
+            if (result == UNRESOLVED_ANSWER) revert QuestionReplacementWasSettledTooSoonAndHasNotBeenReopened();
         }
         return result;
     }
@@ -701,26 +518,39 @@ contract RealityETH_ERC20_v3_0 is BalanceHolder_ERC20 {
     /// @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) {
-
+    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
 
-        require(isSettledTooSoon(reopens_question_id), "You can only reopen questions that resolved as settled too soon");
+        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
-        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 (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.
-        require(!reopener_questions[reopens_question_id], "Question is already reopening a previous 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];
@@ -729,7 +559,7 @@ contract RealityETH_ERC20_v3_0 is BalanceHolder_ERC20 {
         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");
+            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;
@@ -757,16 +587,11 @@ contract RealityETH_ERC20_v3_0 is BalanceHolder_ERC20 {
     /// @param min_timeout The timeout set in the initial question settings must be this high or higher
     /// @param min_bond The bond sent with the final answer must be this high or higher
     /// @return The answer formatted as a bytes32
-    function getFinalAnswerIfMatches(
-        bytes32 question_id, 
-        bytes32 content_hash, address arbitrator, uint32 min_timeout, uint256 min_bond
-    ) 
-        stateFinalized(question_id)
-    external view returns (bytes32) {
-        require(content_hash == questions[question_id].content_hash, "content hash must match");
-        require(arbitrator == questions[question_id].arbitrator, "arbitrator must match");
-        require(min_timeout <= questions[question_id].timeout, "timeout must be long enough");
-        require(min_bond <= questions[question_id].bond, "bond must be high enough");
+    function getFinalAnswerIfMatches(bytes32 question_id, bytes32 content_hash, address arbitrator, uint32 min_timeout, uint256 min_bond) external view stateFinalized(question_id) returns (bytes32) {
+        if (content_hash != questions[question_id].content_hash) revert ContentHashMustMatch();
+        if (arbitrator != questions[question_id].arbitrator) revert ArbitratorMustMatch();
+        if (min_timeout > questions[question_id].timeout) revert TimeoutMustBeLongEnough();
+        if (min_bond > questions[question_id].bond) revert BondMustBeHighEnough();
         return questions[question_id].best_answer;
     }
 
@@ -781,22 +606,16 @@ contract RealityETH_ERC20_v3_0 is BalanceHolder_ERC20 {
     /// Usually you would call the whole thing in a single transaction, but if not then the data is persisted to pick up later.
     /// @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 or commitment sender
-    /// @param bonds Last-to-first, the bond supplied with each answer or commitment
-    /// @param answers Last-to-first, each answer supplied, or commitment ID if the answer was supplied with commit->reveal
-    function claimWinnings(
-        bytes32 question_id, 
-        bytes32[] memory history_hashes, address[] memory addrs, uint256[] memory bonds, bytes32[] memory answers
-    ) 
-        stateFinalized(question_id)
-    public {
-
-        require(history_hashes.length > 0, "at least one history hash entry must be provided");
+    /// @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 claimWinnings(bytes32 question_id, bytes32[] memory history_hashes, address[] memory addrs, uint256[] memory bonds, bytes32[] memory answers) public stateFinalized(question_id) {
+        if (history_hashes.length == 0) revert AtLeastOneHistoryHashEntryMustBeProvided();
 
         // These are only set if we split our claim over multiple transactions.
-        address payee = question_claims[question_id].payee; 
-        uint256 last_bond = question_claims[question_id].last_bond; 
-        uint256 queued_funds = question_claims[question_id].queued_funds; 
+        address payee = question_claims[question_id].payee;
+        uint256 last_bond = question_claims[question_id].last_bond;
+        uint256 queued_funds = 0;
 
         // Starts as the hash of the final answer submitted. It'll be cleared when we're done.
         // If we're splitting the claim over multiple transactions, it'll be the hash where we left off last time
@@ -806,15 +625,11 @@ contract RealityETH_ERC20_v3_0 is BalanceHolder_ERC20 {
 
         uint256 i;
         for (i = 0; i < history_hashes.length; i++) {
-        
-            // Check input against the history hash, and see which of 2 possible values of is_commitment fits.
-            bool is_commitment = _verifyHistoryInputOrRevert(last_history_hash, history_hashes[i], answers[i], bonds[i], addrs[i]);
-            
-            queued_funds = queued_funds + last_bond; 
-            (queued_funds, payee) = _processHistoryItem(
-                question_id, best_answer, queued_funds, payee, 
-                addrs[i], bonds[i], answers[i], is_commitment);
- 
+            _verifyHistoryInputOrRevert(last_history_hash, history_hashes[i], answers[i], bonds[i], addrs[i]);
+
+            queued_funds = queued_funds + last_bond;
+            (queued_funds, payee) = _processHistoryItem(question_id, best_answer, queued_funds, payee, addrs[i], bonds[i], answers[i]);
+
             // Line the bond up for next time, when it will be added to somebody's queued_funds
             last_bond = bonds[i];
 
@@ -825,23 +640,17 @@ contract RealityETH_ERC20_v3_0 is BalanceHolder_ERC20 {
             }
 
             last_history_hash = history_hashes[i];
-
         }
- 
+
         if (last_history_hash != NULL_HASH) {
             // We haven't yet got to the null hash (1st answer), ie the caller didn't supply the full answer chain.
             // Persist the details so we can pick up later where we left off later.
 
-            // If we know who to pay we can go ahead and pay them out, only keeping back last_bond
-            // (We always know who to pay unless all we saw were unrevealed commits)
-            if (payee != NULL_ADDRESS) {
-                _payPayee(question_id, payee, queued_funds);
-                queued_funds = 0;
-            }
+            // Pay out the latest payee, only keeping back last_bond which the next may have a claim on
+            _payPayee(question_id, payee, queued_funds);
 
             question_claims[question_id].payee = payee;
             question_claims[question_id].last_bond = last_bond;
-            question_claims[question_id].queued_funds = queued_funds;
         } else {
             // There is nothing left below us so the payee can keep what remains
             _payPayee(question_id, payee, queued_funds + last_bond);
@@ -849,54 +658,22 @@ contract RealityETH_ERC20_v3_0 is BalanceHolder_ERC20 {
         }
 
         questions[question_id].history_hash = last_history_hash;
-
     }
 
-    function _payPayee(bytes32 question_id, address payee, uint256 value) 
-    internal {
+    function _payPayee(bytes32 question_id, address payee, uint256 value) internal {
         balanceOf[payee] = balanceOf[payee] + value;
         emit LogClaim(question_id, payee, value);
     }
 
-    function _verifyHistoryInputOrRevert(
-        bytes32 last_history_hash,
-        bytes32 history_hash, bytes32 answer, uint256 bond, address addr
-    )
-    internal pure returns (bool) {
-        if (last_history_hash == keccak256(abi.encodePacked(history_hash, answer, bond, addr, true)) ) {
-            return true;
+    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();
         }
-        if (last_history_hash == keccak256(abi.encodePacked(history_hash, answer, bond, addr, false)) ) {
-            return false;
-        } 
-        revert("History input provided did not match the expected hash");
     }
 
-    function _processHistoryItem(
-        bytes32 question_id, bytes32 best_answer, 
-        uint256 queued_funds, address payee, 
-        address addr, uint256 bond, bytes32 answer, bool is_commitment
-    )
-    internal returns (uint256, address) {
-
-        // For commit-and-reveal, the answer history holds the commitment ID instead of the answer.
-        // We look at the referenced commitment ID and switch in the actual answer.
-        if (is_commitment) {
-            bytes32 commitment_id = answer;
-            // If it's a commit but it hasn't been revealed, it will always be considered wrong.
-            if (!commitments[commitment_id].is_revealed) {
-                delete commitments[commitment_id];
-                return (queued_funds, payee);
-            } else {
-                answer = commitments[commitment_id].revealed_answer;
-                delete commitments[commitment_id];
-            }
-        }
-
+    function _processHistoryItem(bytes32 question_id, bytes32 best_answer, uint256 queued_funds, address payee, address addr, uint256 bond, bytes32 answer) internal returns (uint256, address) {
         if (answer == best_answer) {
-
             if (payee == NULL_ADDRESS) {
-
                 // The entry is for the first payee we come to, ie the winner.
                 // They get the question bounty.
                 payee = addr;
@@ -905,13 +682,11 @@ contract RealityETH_ERC20_v3_0 is BalanceHolder_ERC20 {
                     _payPayee(question_id, payee, questions[question_id].bounty);
                     questions[question_id].bounty = 0;
                 }
-
             } else if (addr != payee) {
-
                 // Answerer has changed, ie we found someone lower down who needs to be paid
 
                 // The lower answerer will take over receiving bonds from higher answerer.
-                // They should also be paid the takeover fee, which is set at a rate equivalent to their bond. 
+                // They should also be paid the takeover fee, which is set at a rate equivalent to their bond.
                 // (This is our arbitrary rule, to give consistent right-answerers a defence against high-rollers.)
 
                 // There should be enough for the fee, but if not, take what we have.
@@ -923,13 +698,10 @@ contract RealityETH_ERC20_v3_0 is BalanceHolder_ERC20 {
                 // Now start queued_funds again for the new (lower-bonded) payee
                 payee = addr;
                 queued_funds = answer_takeover_fee;
-
             }
-
         }
 
         return (queued_funds, payee);
-
     }
 
     /// @notice Convenience function to assign bounties/bonds for multiple questions in one go, then withdraw all your funds.
@@ -938,16 +710,20 @@ contract RealityETH_ERC20_v3_0 is BalanceHolder_ERC20 {
     /// @param question_ids The IDs of the questions you want to claim for
     /// @param lengths The number of history entries you will supply for each question ID
     /// @param hist_hashes In a single list for all supplied questions, the hash of each history entry.
-    /// @param addrs In a single list for all supplied questions, the address of each answerer or commitment sender
-    /// @param bonds In a single list for all supplied questions, the bond supplied with each answer or commitment
-    /// @param answers In a single list for all supplied questions, each answer supplied, or commitment ID 
+    /// @param addrs In a single list for all supplied questions, the address of each answerer
+    /// @param bonds In a single list for all supplied questions, the bond supplied with each answer
+    /// @param answers In a single list for all supplied questions, each answer supplied
     function claimMultipleAndWithdrawBalance(
-        bytes32[] memory question_ids, uint256[] memory lengths, 
-        bytes32[] memory hist_hashes, address[] memory addrs, uint256[] memory bonds, bytes32[] memory answers
-    ) 
-        stateAny() // The finalization checks are done in the claimWinnings function
-    public {
-        
+        bytes32[] memory question_ids,
+        uint256[] memory lengths,
+        bytes32[] memory hist_hashes,
+        address[] memory addrs,
+        uint256[] memory bonds,
+        bytes32[] memory answers
+    )
+        public
+        stateAny // The finalization checks are done in the claimWinnings function
+    {
         uint256 qi;
         uint256 i;
         for (qi = 0; qi < question_ids.length; qi++) {
@@ -971,82 +747,70 @@ contract RealityETH_ERC20_v3_0 is BalanceHolder_ERC20 {
     }
 
     /// @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) {
+    /// @param question_id The ID of the question
+    function getContentHash(bytes32 question_id) public view returns (bytes32) {
         return questions[question_id].content_hash;
     }
 
     /// @notice Returns the arbitrator address for the question
-    /// @param question_id The ID of the question 
-    function getArbitrator(bytes32 question_id) 
-    public view returns(address) {
+    /// @param question_id The ID of the question
+    function getArbitrator(bytes32 question_id) public view returns (address) {
         return questions[question_id].arbitrator;
     }
 
     /// @notice Returns the timestamp when the question can first be answered
-    /// @param question_id The ID of the question 
-    function getOpeningTS(bytes32 question_id) 
-    public view returns(uint32) {
+    /// @param question_id The ID of the question
+    function getOpeningTS(bytes32 question_id) public view returns (uint32) {
         return questions[question_id].opening_ts;
     }
 
     /// @notice Returns the timeout in seconds used after each answer
-    /// @param question_id The ID of the question 
-    function getTimeout(bytes32 question_id) 
-    public view returns(uint32) {
+    /// @param question_id The ID of the question
+    function getTimeout(bytes32 question_id) public view returns (uint32) {
         return questions[question_id].timeout;
     }
 
     /// @notice Returns the timestamp at which the question will be/was finalized
-    /// @param question_id The ID of the question 
-    function getFinalizeTS(bytes32 question_id) 
-    public view returns(uint32) {
+    /// @param question_id The ID of the question
+    function getFinalizeTS(bytes32 question_id) public view returns (uint32) {
         return questions[question_id].finalize_ts;
     }
 
     /// @notice Returns whether the question is pending arbitration
-    /// @param question_id The ID of the question 
-    function isPendingArbitration(bytes32 question_id) 
-    public view returns(bool) {
+    /// @param question_id The ID of the question
+    function isPendingArbitration(bytes32 question_id) public view returns (bool) {
         return questions[question_id].is_pending_arbitration;
     }
 
     /// @notice Returns the current total unclaimed bounty
     /// @dev Set back to zero once the bounty has been claimed
-    /// @param question_id The ID of the question 
-    function getBounty(bytes32 question_id) 
-    public view returns(uint256) {
+    /// @param question_id The ID of the question
+    function getBounty(bytes32 question_id) public view returns (uint256) {
         return questions[question_id].bounty;
     }
 
     /// @notice Returns the current best answer
-    /// @param question_id The ID of the question 
-    function getBestAnswer(bytes32 question_id) 
-    public view returns(bytes32) {
+    /// @param question_id The ID of the question
+    function getBestAnswer(bytes32 question_id) public view returns (bytes32) {
         return questions[question_id].best_answer;
     }
 
-    /// @notice Returns the history hash of the question 
-    /// @param question_id The ID of the question 
+    /// @notice Returns the history hash of the question
+    /// @param question_id The ID of the question
     /// @dev Updated on each answer, then rewound as each is claimed
-    function getHistoryHash(bytes32 question_id) 
-    public view returns(bytes32) {
+    function getHistoryHash(bytes32 question_id) public view returns (bytes32) {
         return questions[question_id].history_hash;
     }
 
     /// @notice Returns the highest bond posted so far for a question
-    /// @param question_id The ID of the question 
-    function getBond(bytes32 question_id) 
-    public view returns(uint256) {
+    /// @param question_id The ID of the question
+    function getBond(bytes32 question_id) public view returns (uint256) {
         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) {
+    function getMinBond(bytes32 question_id) public view returns (uint256) {
         return questions[question_id].min_bond;
     }
-
 }