Cryo Explorer Ethereum Mainnet

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC1155/IERC1155Receiver.sol)

pragma solidity ^0.8.20;

import {IERC165} from "../../utils/introspection/IERC165.sol";

/**
 * @dev Interface that must be implemented by smart contracts in order to receive
 * ERC-1155 token transfers.
 */
interface IERC1155Receiver is IERC165 {
    /**
     * @dev Handles the receipt of a single ERC-1155 token type. This function is
     * called at the end of a `safeTransferFrom` after the balance has been updated.
     *
     * NOTE: To accept the transfer, this must return
     * `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
     * (i.e. 0xf23a6e61, or its own function selector).
     *
     * @param operator The address which initiated the transfer (i.e. msg.sender)
     * @param from The address which previously owned the token
     * @param id The ID of the token being transferred
     * @param value The amount of tokens being transferred
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed
     */
    function onERC1155Received(
        address operator,
        address from,
        uint256 id,
        uint256 value,
        bytes calldata data
    ) external returns (bytes4);

    /**
     * @dev Handles the receipt of a multiple ERC-1155 token types. This function
     * is called at the end of a `safeBatchTransferFrom` after the balances have
     * been updated.
     *
     * NOTE: To accept the transfer(s), this must return
     * `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
     * (i.e. 0xbc197c81, or its own function selector).
     *
     * @param operator The address which initiated the batch transfer (i.e. msg.sender)
     * @param from The address which previously owned the token
     * @param ids An array containing ids of each token being transferred (order and length must match values array)
     * @param values An array containing amounts of each token being transferred (order and length must match ids array)
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed
     */
    function onERC1155BatchReceived(
        address operator,
        address from,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external returns (bytes4);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC1155/utils/ERC1155Holder.sol)

pragma solidity ^0.8.20;

import {IERC165, ERC165} from "../../../utils/introspection/ERC165.sol";
import {IERC1155Receiver} from "../IERC1155Receiver.sol";

/**
 * @dev Simple implementation of `IERC1155Receiver` that will allow a contract to hold ERC-1155 tokens.
 *
 * IMPORTANT: When inheriting this contract, you must include a way to use the received tokens, otherwise they will be
 * stuck.
 */
abstract contract ERC1155Holder is ERC165, IERC1155Receiver {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
        return interfaceId == type(IERC1155Receiver).interfaceId || super.supportsInterface(interfaceId);
    }

    function onERC1155Received(
        address,
        address,
        uint256,
        uint256,
        bytes memory
    ) public virtual override returns (bytes4) {
        return this.onERC1155Received.selector;
    }

    function onERC1155BatchReceived(
        address,
        address,
        uint256[] memory,
        uint256[] memory,
        bytes memory
    ) public virtual override returns (bytes4) {
        return this.onERC1155BatchReceived.selector;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/ERC165.sol)

pragma solidity ^0.8.20;

import {IERC165} from "./IERC165.sol";

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC-165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/IERC165.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC-165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[ERC].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

/**
 *  @authors: [@xyzseer]
 *  @reviewers: []
 *  @auditors: []
 *  @bounties: []
 *  @deployments: []
 */

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

import "./FutarchyRealityProxy.sol";
import {IERC20} from "./Interfaces.sol";

contract FutarchyProposal {
    /// @dev Flag to initialize the proposal only once.
    bool public initialized;

    /// @dev Contains the information associated to the proposal.
    /// @param conditionId Conditional Tokens conditionId.
    /// @param collateralToken1 First collateral token.
    /// @param collateralToken2 Second collateral token.
    /// @param parentCollectionId Conditional Tokens parentCollectionId.
    /// @param parentOutcome Conditional outcome to use (optional).
    /// @param parentMarket Conditional proposal to use (optional).
    /// @param questionId Conditional Tokens questionId.
    /// @param encodedQuestion Encoded question, needed to create and reopen a question.
    /// @param wrapped1155 Outcome tokens Wrapped1155 address.
    /// @param data Wrapped1155 token data.
    struct FutarchyProposalParams {
        bytes32 conditionId;
        IERC20 collateralToken1;
        IERC20 collateralToken2;
        bytes32 parentCollectionId;
        uint256 parentOutcome;
        address parentMarket;
        bytes32 questionId;
        string encodedQuestion;
        IERC20[] wrapped1155;
        bytes[] tokenData;
    }

    /// @dev The name of the proposal.
    string public marketName;
    /// @dev The proposal outcomes.
    string[] public outcomes;
    /// @dev Proposal parameters.
    FutarchyProposalParams public futarchyProposalParams;
    /// @dev Oracle contract.
    FutarchyRealityProxy public realityProxy;

    /// @dev Initializer.
    /// @param _marketName The name of the proposal.
    /// @param _outcomes The proposal outcomes.
    /// @param _futarchyProposalParams Futarchy Proposal params.
    /// @param _realityProxy Oracle contract.
    function initialize(
        string memory _marketName,
        string[] memory _outcomes,
        FutarchyProposalParams memory _futarchyProposalParams,
        FutarchyRealityProxy _realityProxy
    ) external {
        require(!initialized, "Already initialized.");

        marketName = _marketName;
        outcomes = _outcomes;
        futarchyProposalParams = _futarchyProposalParams;
        realityProxy = _realityProxy;

        initialized = true;
    }

    /// @dev Encoded question parameters, needed to create and reopen a question.
    /// @return The encoded question.
    function encodedQuestion() external view returns (string memory) {
        return futarchyProposalParams.encodedQuestion;
    }

    /// @dev Conditional Tokens questionId.
    /// @return the question ID.
    function questionId() external view returns (bytes32) {
        return futarchyProposalParams.questionId;
    }

    /// @dev Conditional Tokens conditionId.
    /// @return The condition ID.
    function conditionId() external view returns (bytes32) {
        return futarchyProposalParams.conditionId;
    }

    /// @dev First collateral token.
    /// @return The collateral token.
    function collateralToken1() external view returns (IERC20) {
        return futarchyProposalParams.collateralToken1;
    }

    /// @dev Second collateral token.
    /// @return The collateral token.
    function collateralToken2() external view returns (IERC20) {
        return futarchyProposalParams.collateralToken2;
    }

    /// @dev Conditional Tokens parentCollectionId.
    /// @return The parent collection ID.
    function parentCollectionId() external view returns (bytes32) {
        return futarchyProposalParams.parentCollectionId;
    }

    /// @dev The parent proposal (optional). This proposal redeems to an outcome token of the parent proposal.
    /// @return The parent proposal address.
    function parentMarket() external view returns (address) {
        return futarchyProposalParams.parentMarket;
    }

    /// @dev The parent outcome (optional). The parent proposal's outcome token this proposal redeems for.
    /// @return The parent outcome index.
    function parentOutcome() external view returns (uint256) {
        return futarchyProposalParams.parentOutcome;
    }

    /// @dev Returns the wrapped1155 and the data corresponding to an outcome token.
    /// @param index The outcome index.
    /// @return wrapped1155 The wrapped token.
    /// @return data The token data.
    function wrappedOutcome(uint256 index) external view returns (IERC20 wrapped1155, bytes memory data) {
        return (futarchyProposalParams.wrapped1155[index], futarchyProposalParams.tokenData[index]);
    }

    /// @dev Returns the wrapped1155 and the data corresponding to the parent proposal.
    /// @return wrapped1155 The wrapped token.
    /// @return data The token data.
    function parentWrappedOutcome() external view returns (IERC20 wrapped1155, bytes memory data) {
        if (futarchyProposalParams.parentMarket != address(0)) {
            (wrapped1155, data) = FutarchyProposal(futarchyProposalParams.parentMarket).wrappedOutcome(
                futarchyProposalParams.parentOutcome
            );
        }
    }

    /// @dev Returns the number of outcomes.
    /// @return numOutcomes The number of outcomes.
    function numOutcomes() external view returns (uint256) {
        return outcomes.length;
    }

    /// @dev Helper function to resolve the proposal.
    function resolve() external {
        realityProxy.resolve(this);
    }
}

/**
 *  @authors: [@xyzseer]
 *  @reviewers: []
 *  @auditors: []
 *  @bounties: []
 *  @deployments: []
 */

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

import "./FutarchyProposal.sol";
import {IConditionalTokens, IRealityETH_v3_0} from "./Interfaces.sol";

contract FutarchyRealityProxy {
    /// @dev Conditional Tokens contract.
    IConditionalTokens public immutable conditionalTokens;
    /// @dev Reality.eth contract.
    IRealityETH_v3_0 public immutable realitio;

    /// @dev Constructor.
    /// @param _conditionalTokens Conditional Tokens contract address.
    /// @param _realitio Reality.eth contract address.
    constructor(IConditionalTokens _conditionalTokens, IRealityETH_v3_0 _realitio) {
        conditionalTokens = _conditionalTokens;
        realitio = _realitio;
    }

    /// @dev Resolves the specified proposal.
    /// @param proposal Proposal to resolve. UNTRUSTED.
    function resolve(FutarchyProposal proposal) external {
        bytes32 questionId = proposal.questionId();

        uint256 answer = uint256(realitio.resultForOnceSettled(questionId));
        uint256[] memory payouts = new uint256[](2);

        // FutarchyFactory prepares the condition with two outcomes (YES / NO)
        if (answer == 0) {
            // accept proposal if result is YES
            payouts[0] = 1;
        } else {
            // reject proposal if result is NO or INVALID
            payouts[1] = 1;
        }

        conditionalTokens.reportPayouts(questionId, payouts);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

import "./FutarchyProposal.sol";
import {IConditionalTokens, IERC20, IWrapped1155Factory} from "./Interfaces.sol";
import "@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol";

/// @dev Router implementation that allows to use two collateral tokens.
contract FutarchyRouter is ERC1155Holder {
    /// @dev Conditional Tokens contract.
    IConditionalTokens public immutable conditionalTokens;
    /// @dev Wrapped1155Factory contract.
    IWrapped1155Factory public immutable wrapped1155Factory;

    /// @dev Constructor.
    /// @param _conditionalTokens Conditional Tokens contract.
    /// @param _wrapped1155Factory Wrapped1155Factory contract.
    constructor(IConditionalTokens _conditionalTokens, IWrapped1155Factory _wrapped1155Factory) {
        conditionalTokens = _conditionalTokens;
        wrapped1155Factory = _wrapped1155Factory;
    }

    /// @notice Transfers the collateral to the Router, splits the position and sends the ERC20 outcome tokens back to the user.
    /// @dev The ERC20 associated to each outcome must be previously created on the wrapped1155Factory.
    /// @dev Collateral tokens are deposited only if we are not splitting a deep position (parentCollectionId is bytes32(0)).
    /// @param proposal The Proposal to split.
    /// @param collateralToken The address of the ERC20 used as collateral.
    /// @param amount The amount of collateral to split.
    function splitPosition(FutarchyProposal proposal, IERC20 collateralToken, uint256 amount) public {
        if (proposal.parentCollectionId() == bytes32(0)) {
            // transfer the collateral tokens to the Router.
            collateralToken.transferFrom(msg.sender, address(this), amount);
        }
        _splitPosition(proposal, collateralToken, amount);
    }

    /// @notice Splits a position and sends the ERC20 outcome tokens to the user.
    /// @dev The ERC20 associated to each outcome must be previously created on the wrapped1155Factory.
    /// @param proposal The Proposal to split.
    /// @param collateralToken The address of the ERC20 used as collateral.
    /// @param amount The amount of collateral to split.
    function _splitPosition(FutarchyProposal proposal, IERC20 collateralToken, uint256 amount) internal {
        bytes32 parentCollectionId = proposal.parentCollectionId();
        bytes32 conditionId = proposal.conditionId();

        uint256[] memory partition = new uint256[](2);
        partition[0] = 1;
        partition[1] = 2;

        if (parentCollectionId != bytes32(0)) {
            // it's splitting from a parent position, so we need to unwrap these tokens first because they will be burnt to mint the child outcome tokens.
            (IERC20 wrapped1155, bytes memory data) = proposal.parentWrappedOutcome();

            uint256 tokenId = conditionalTokens.getPositionId(address(collateralToken), parentCollectionId);

            wrapped1155.transferFrom(msg.sender, address(this), amount);
            wrapped1155Factory.unwrap(address(conditionalTokens), tokenId, amount, address(this), data);
        } else {
            collateralToken.approve(address(conditionalTokens), amount);
        }

        conditionalTokens.splitPosition(address(collateralToken), parentCollectionId, conditionId, partition, amount);

        bool isFirstCollateral = collateralToken == proposal.collateralToken1();

        // wrap & transfer the minted outcome tokens.
        for (uint256 j = 0; j < 2; j++) {
            uint256 tokenId = getTokenId(collateralToken, parentCollectionId, conditionId, 1 << j);

            (IERC20 wrapped1155, bytes memory data) = proposal.wrappedOutcome(isFirstCollateral ? j : j + 2);

            // wrap to erc20.
            conditionalTokens.safeTransferFrom(address(this), address(wrapped1155Factory), tokenId, amount, data);

            // transfer the ERC20 back to the user.
            require(wrapped1155.transfer(msg.sender, amount), "Wrapped token transfer failed");
        }
    }

    /// @notice Merges positions and sends the collateral tokens to the user.
    /// @dev The ERC20 associated to each outcome must be previously created on the wrapped1155Factory.
    /// @dev Collateral tokens are withdrawn only if we are not merging a deep position (parentCollectionId is bytes32(0)).
    /// @param proposal The Proposal to merge.
    /// @param collateralToken The address of the ERC20 used as collateral.
    /// @param amount The amount of outcome tokens to merge.
    function mergePositions(FutarchyProposal proposal, IERC20 collateralToken, uint256 amount) public {
        _mergePositions(proposal, collateralToken, amount);

        if (proposal.parentCollectionId() == bytes32(0)) {
            // send collateral tokens back to the user.
            require(collateralToken.transfer(msg.sender, amount), "Collateral transfer failed");
        }
    }

    /// @notice Merges positions and receives the collateral tokens.
    /// @dev Callers to this function must send the collateral to the user.
    /// @param proposal The Proposal to merge.
    /// @param collateralToken The address of the ERC20 used as collateral.
    /// @param amount The amount of outcome tokens to merge.
    function _mergePositions(FutarchyProposal proposal, IERC20 collateralToken, uint256 amount) internal {
        bytes32 parentCollectionId = proposal.parentCollectionId();
        bytes32 conditionId = proposal.conditionId();

        uint256[] memory partition = new uint256[](2);
        partition[0] = 1;
        partition[1] = 2;

        bool isFirstCollateral = collateralToken == proposal.collateralToken1();

        // we need to unwrap the outcome tokens because they will be burnt during the merge.
        for (uint256 j = 0; j < 2; j++) {
            uint256 tokenId = getTokenId(collateralToken, parentCollectionId, conditionId, 1 << j);

            (IERC20 wrapped1155, bytes memory data) = proposal.wrappedOutcome(isFirstCollateral ? j : j + 2);

            wrapped1155.transferFrom(msg.sender, address(this), amount);
            wrapped1155Factory.unwrap(address(conditionalTokens), tokenId, amount, address(this), data);
        }

        conditionalTokens.mergePositions(address(collateralToken), parentCollectionId, conditionId, partition, amount);

        if (parentCollectionId != bytes32(0)) {
            // it's merging from a parent position, so we need to wrap these tokens and send them back to the user.
            uint256 tokenId = conditionalTokens.getPositionId(address(collateralToken), parentCollectionId);

            (IERC20 wrapped1155, bytes memory data) = proposal.parentWrappedOutcome();

            // wrap to erc20.
            conditionalTokens.safeTransferFrom(address(this), address(wrapped1155Factory), tokenId, amount, data);

            // transfer the ERC20 back to the user.
            require(wrapped1155.transfer(msg.sender, amount), "Wrapped token transfer failed");
        }
    }

    /// @notice Redeems positions and sends the collateral tokens to the user.
    /// @dev The ERC20 associated to each outcome must be previously created on the wrapped1155Factory.
    /// @dev Collateral tokens are withdrawn only if we are not redeeming a deep position (parentCollectionId is bytes32(0)).
    /// @param proposal The Proposal to redeem.
    /// @param amount1 Amount to redeem for the first collateral.
    /// @param amount2 Amount to redeem for the second collateral.
    function redeemProposal(FutarchyProposal proposal, uint256 amount1, uint256 amount2) external {
        redeemPositions(proposal, proposal.collateralToken1(), amount1);
        redeemPositions(proposal, proposal.collateralToken2(), amount2);
    }

    /// @notice Redeems positions and sends the collateral tokens to the user.
    /// @dev The ERC20 associated to each outcome must be previously created on the wrapped1155Factory.
    /// @dev Collateral tokens are withdrawn only if we are not redeeming a deep position (parentCollectionId is bytes32(0)).
    /// @param proposal The Proposal to redeem.
    /// @param collateralToken The address of the ERC20 used as collateral.
    /// @param amount Amount to redeem.
    function redeemPositions(FutarchyProposal proposal, IERC20 collateralToken, uint256 amount) public {
        bytes32 parentCollectionId = proposal.parentCollectionId();
        uint256 initialBalance;

        if (parentCollectionId == bytes32(0)) {
            initialBalance = collateralToken.balanceOf(address(this));
        }

        _redeemPositions(proposal, collateralToken, amount);

        if (parentCollectionId == bytes32(0)) {
            uint256 finalBalance = collateralToken.balanceOf(address(this));

            if (finalBalance > initialBalance) {
                // send collateral tokens back to the user.
                require(
                    collateralToken.transfer(msg.sender, finalBalance - initialBalance), "Collateral transfer failed"
                );
            }
        }
    }

    /// @notice Redeems positions and receives the collateral tokens.
    /// @dev Callers to this function must send the collateral to the user.
    /// @param proposal The Proposal to redeem.
    /// @param collateralToken The address of the ERC20 used as collateral.
    /// @param amount Amount to redeem.
    function _redeemPositions(FutarchyProposal proposal, IERC20 collateralToken, uint256 amount) internal {
        bytes32 parentCollectionId = proposal.parentCollectionId();
        bytes32 conditionId = proposal.conditionId();

        uint256[] memory indexSets = new uint256[](1);
        bool isApproved = conditionalTokens.payoutNumerators(conditionId, 0) == 1;
        uint256 j = isApproved ? 0 : 1;
        indexSets[0] = 1 << j;
        uint256 tokenId = getTokenId(collateralToken, parentCollectionId, conditionId, indexSets[0]);

        // first we need to unwrap the outcome tokens that will be redeemed.
        (IERC20 wrapped1155, bytes memory data) =
            proposal.wrappedOutcome(collateralToken == proposal.collateralToken1() ? j : j + 2);

        wrapped1155.transferFrom(msg.sender, address(this), amount);

        wrapped1155Factory.unwrap(address(conditionalTokens), tokenId, amount, address(this), data);

        uint256 initialBalance = 0;

        if (parentCollectionId != bytes32(0)) {
            // if we are redeeming from a child market, the user may already have parent tokens so we need to track the balance change.
            tokenId = conditionalTokens.getPositionId(address(collateralToken), parentCollectionId);
            initialBalance = conditionalTokens.balanceOf(address(this), tokenId);
        }

        conditionalTokens.redeemPositions(address(collateralToken), parentCollectionId, conditionId, indexSets);

        if (parentCollectionId != bytes32(0)) {
            // if we are redeeming from a child market, redeemPositions() returned outcome tokens of the parent market. We need to wrap and send them to the user.
            uint256 finalBalance = conditionalTokens.balanceOf(address(this), tokenId);

            if (finalBalance > initialBalance) {
                // wrap to erc20.
                (IERC20 parentWrapped1155, bytes memory parentData) = proposal.parentWrappedOutcome();

                conditionalTokens.safeTransferFrom(
                    address(this), address(wrapped1155Factory), tokenId, finalBalance - initialBalance, parentData
                );

                // transfer the ERC20 back to the user.
                require(
                    parentWrapped1155.transfer(msg.sender, finalBalance - initialBalance),
                    "Parent wrapped token transfer failed"
                );
            }
        }
    }

    /// @notice Constructs a tokenId from a collateral token and an outcome collection.
    /// @param collateralToken The address of the ERC20 used as collateral.
    /// @param parentCollectionId The Conditional Tokens parent collection id.
    /// @param conditionId The id of the condition used to redeem.
    /// @param indexSet Index set of the outcome collection to combine with the parent outcome collection.
    /// @return The token id.
    function getTokenId(
        IERC20 collateralToken,
        bytes32 parentCollectionId,
        bytes32 conditionId,
        uint256 indexSet
    ) public view returns (uint256) {
        bytes32 collectionId = conditionalTokens.getCollectionId(parentCollectionId, conditionId, indexSet);
        return conditionalTokens.getPositionId(address(collateralToken), collectionId);
    }

    /// @notice Helper function used to know the redeemable outcomes associated to a conditionId.
    /// @param conditionId The id of the condition.
    /// @return An array of outcomes where a true value indicates that the outcome is redeemable.
    function getWinningOutcomes(bytes32 conditionId) external view returns (bool[] memory) {
        bool[] memory result = new bool[](conditionalTokens.getOutcomeSlotCount(conditionId));

        for (uint256 i = 0; i < result.length; i++) {
            result[i] = conditionalTokens.payoutNumerators(conditionId, i) == 0 ? false : true;
        }

        return result;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

interface IERC20 {
    function symbol() external view returns (string memory);

    function transferFrom(address from, address to, uint256 amount) external returns (bool);

    function transfer(address to, uint256 amount) external returns (bool);

    function approve(address spender, uint256 amount) external returns (bool);

    function balanceOf(address owner) external returns (uint256);

    function totalSupply() external view returns (uint256);
}

// https://github.com/RealityETH/reality-eth-monorepo/blob/main/packages/contracts/flat/RealityETH-3.0.sol
interface IRealityETH_v3_0 {
    function askQuestionWithMinBond(
        uint256 template_id,
        string memory question,
        address arbitrator,
        uint32 timeout,
        uint32 opening_ts,
        uint256 nonce,
        uint256 min_bond
    ) external payable returns (bytes32);

    function resultForOnceSettled(bytes32 question_id) external view returns (bytes32);

    function getContentHash(bytes32 question_id) external view returns (bytes32);

    function getTimeout(bytes32 question_id) external view returns (uint32);

    function submitAnswer(bytes32 question_id, bytes32 answer, uint256 max_previous) external payable;
}

interface IConditionalTokens {
    function payoutNumerators(bytes32 conditionId, uint256 index) external view returns (uint256);

    function payoutDenominator(bytes32 conditionId) external view returns (uint256);

    function prepareCondition(address oracle, bytes32 questionId, uint256 outcomeSlotCount) external;

    function reportPayouts(bytes32 questionId, uint256[] calldata payouts) external;

    function splitPosition(
        /*IERC20*/
        address collateralToken,
        bytes32 parentCollectionId,
        bytes32 conditionId,
        uint256[] calldata partition,
        uint256 amount
    ) external;

    function mergePositions(
        /*IERC20*/
        address collateralToken,
        bytes32 parentCollectionId,
        bytes32 conditionId,
        uint256[] calldata partition,
        uint256 amount
    ) external;

    function redeemPositions(
        /*IERC20*/
        address collateralToken,
        bytes32 parentCollectionId,
        bytes32 conditionId,
        uint256[] calldata indexSets
    ) external;

    function getConditionId(
        address oracle,
        bytes32 questionId,
        uint256 outcomeSlotCount
    ) external pure returns (bytes32);

    function getCollectionId(
        bytes32 parentCollectionId,
        bytes32 conditionId,
        uint256 indexSet
    ) external view returns (bytes32);

    function getPositionId(address collateralToken, bytes32 collectionId) external pure returns (uint256);

    function getOutcomeSlotCount(bytes32 conditionId) external view returns (uint256);

    function safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes calldata data) external;

    function balanceOf(address owner, uint256 id) external view returns (uint256);
}

interface IWrapped1155Factory {
    function requireWrapped1155(
        /*IERC1155*/
        address multiToken,
        uint256 tokenId,
        bytes calldata data
    ) external /*Wrapped1155*/ returns (IERC20);

    function unwrap(
        /*IERC1155*/
        address multiToken,
        uint256 tokenId,
        uint256 amount,
        address recipient,
        bytes calldata data
    ) external;
}