// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.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 ERC1155 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.0.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 ERC165 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.0.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 ERC1155 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 ERC1155 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.0.0) (utils/introspection/IERC165.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * 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[EIP 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);
}

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

interface IERC20 {
    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;
}

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

import "./Router.sol";

interface ISavingsDai is IERC20 {
    function deposit(uint256 assets, address receiver) external returns (uint256 shares);

    function redeem(uint256 shares, address receiver, address owner) external returns (uint256 assets);
}

/// @dev Router implementation with functions to interact with DAI on Ethereum Mainnet.
contract MainnetRouter is Router {
    /// @dev DAI address.
    IERC20 public constant DAI = IERC20(0x6B175474E89094C44Da98b954EedeAC495271d0F);
    /// @dev SavingsDai address.
    ISavingsDai public constant sDAI = ISavingsDai(0x83F20F44975D03b1b09e64809B757c47f942BEeA);

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

    /// @notice Splits a position using DAI and sends the ERC20 outcome tokens back to the user.
    /// @dev The ERC20 associated to each outcome must be previously created on the wrapped1155Factory.
    /// @param market The Market to split.
    /// @param amount The amount of collateral to split.
    function splitFromDai(Market market, uint256 amount) external {
        DAI.transferFrom(msg.sender, address(this), amount);
        DAI.approve(address(sDAI), amount);
        uint256 shares = sDAI.deposit(amount, address(this));

        _splitPosition(IERC20(address(sDAI)), market, shares);
    }

    /// @notice Merges positions and sends DAI to the user.
    /// @dev The ERC20 associated to each outcome must be previously created on the wrapped1155Factory.
    /// @param market The Market to merge.
    /// @param amount The amount of outcome tokens to merge.
    function mergeToDai(Market market, uint256 amount) external {
        _mergePositions(IERC20(address(sDAI)), market, amount);
        sDAI.redeem(amount, msg.sender, address(this));
    }

    /// @notice Redeems positions and sends DAI to the user.
    /// @dev The ERC20 associated to each outcome must be previously created on the wrapped1155Factory.
    /// @param market The Market to redeem.
    /// @param outcomeIndexes The index of the outcomes to redeem.
    /// @param amounts Amount to redeem of each outcome.
    function redeemToDai(Market market, uint256[] calldata outcomeIndexes, uint256[] calldata amounts) external {
        uint256 initialBalance = sDAI.balanceOf(address(this));

        _redeemPositions(sDAI, market, outcomeIndexes, amounts);

        uint256 finalBalance = sDAI.balanceOf(address(this));

        if (finalBalance > initialBalance) {
            sDAI.redeem(finalBalance - initialBalance, msg.sender, address(this));
        }
    }
}

/**
 *  @authors: [@xyzseer]
 *  @reviewers: [@nvm1410, @madhurMongia, @unknownunknown1, @mani99brar]
 *  @auditors: []
 *  @bounties: []
 *  @deployments: []
 */

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

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

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

    /// @dev Contains the information associated to Reality.
    /// @param questionsIds Reality questions ids.
    /// @param templateId Reality templateId.
    /// @param encodedQuestions Encoded questions parameters, needed to create and reopen a question.
    struct RealityParams {
        bytes32[] questionsIds;
        uint256 templateId;
        string[] encodedQuestions;
    }

    /// @dev Contains the information associated to Conditional Tokens.
    /// @param conditionId Conditional Tokens conditionId.
    /// @param parentCollectionId Conditional Tokens parentCollectionId.
    /// @param parentOutcome Conditional outcome to use (optional).
    /// @param parentMarket Conditional market to use (optional).
    /// @param questionId Conditional Tokens questionId.
    /// @param wrapped1155 Outcome tokens Wrapped1155 address.
    /// @param data Wrapped1155 token data.
    struct ConditionalTokensParams {
        bytes32 conditionId;
        bytes32 parentCollectionId;
        uint256 parentOutcome;
        address parentMarket;
        bytes32 questionId;
        IERC20[] wrapped1155;
        bytes[] data;
    }

    /// @dev The name of the market.
    string public marketName;
    /// @dev The market outcomes, doesn't include the INVALID_RESULT outcome.
    string[] public outcomes;
    /// @dev Lower bound, only used for scalar markets.
    uint256 public lowerBound;
    /// @dev Upper bound, only used for scalar markets.
    uint256 public upperBound;
    /// @dev Conditional Tokens parameters.
    ConditionalTokensParams public conditionalTokensParams;
    /// @dev Reality parameters.
    RealityParams public realityParams;
    /// @dev Oracle contract.
    RealityProxy public realityProxy;

    /// @dev Initializer.
    /// @param _marketName The name of the market.
    /// @param _outcomes The market outcomes, doesn't include the INVALID_RESULT outcome.
    /// @param _lowerBound Lower bound, only used for scalar markets.
    /// @param _upperBound Upper bound, only used for scalar markets.
    /// @param _conditionalTokensParams Conditional Tokens params.
    /// @param _realityParams Reality params.
    /// @param _realityProxy Oracle contract.
    function initialize(
        string memory _marketName,
        string[] memory _outcomes,
        uint256 _lowerBound,
        uint256 _upperBound,
        ConditionalTokensParams memory _conditionalTokensParams,
        RealityParams memory _realityParams,
        RealityProxy _realityProxy
    ) external {
        require(!initialized, "Already initialized.");

        marketName = _marketName;
        outcomes = _outcomes;
        lowerBound = _lowerBound;
        upperBound = _upperBound;
        conditionalTokensParams = _conditionalTokensParams;
        realityParams = _realityParams;
        realityProxy = _realityProxy;

        initialized = true;
    }

    /// @dev The templateId associated to the Reality question.
    /// @return The template id.
    function templateId() external view returns (uint256) {
        return realityParams.templateId;
    }

    /// @dev Returns the Reality questions ids. Multi Scalar markets have one question for each outcome, while any other market has only one question.
    /// @return The Reality questions ids.
    function questionsIds() external view returns (bytes32[] memory) {
        return realityParams.questionsIds;
    }

    /// @dev Encoded questions parameters, needed to create and reopen a question.
    /// @param index The question index.
    /// @return The encoded question.
    function encodedQuestions(uint256 index) external view returns (string memory) {
        return realityParams.encodedQuestions[index];
    }

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

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

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

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

    /// @dev The parent outcome (optional). The parent market's outcome token this market redeems for.
    /// @return The parent outcome index.
    function parentOutcome() external view returns (uint256) {
        return conditionalTokensParams.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 (conditionalTokensParams.wrapped1155[index], conditionalTokensParams.data[index]);
    }

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

    /// @dev Returns the number of outcomes.
    /// Doesn't include the INVALID_RESULT outcome.
    /// @return numOutcomes The number of outcomes.
    function numOutcomes() external view returns (uint256) {
        return outcomes.length;
    }

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

/**
 *  @authors: [@xyzseer]
 *  @reviewers: [@nvm1410, @madhurMongia, @unknownunknown1, @mani99brar]
 *  @auditors: []
 *  @bounties: []
 *  @deployments: []
 */

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

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

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

    /// @dev INVALID_RESULT reserved value.
    bytes32 internal constant INVALID_RESULT = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;

    /// @dev Template for scalar and multi scalar markets.
    uint256 internal constant REALITY_UINT_TEMPLATE = 1;
    /// @dev Template for categorical markets.
    uint256 internal constant REALITY_SINGLE_SELECT_TEMPLATE = 2;
    /// @dev Template for multi categorical markets.
    uint256 internal constant REALITY_MULTI_SELECT_TEMPLATE = 3;

    /// @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 market.
    /// @param market Market to resolve. UNTRUSTED.
    function resolve(Market market) external {
        bytes32[] memory questionsIds = market.questionsIds();
        uint256 numOutcomes = market.numOutcomes();
        uint256 templateId = market.templateId();
        uint256 low = market.lowerBound();
        uint256 high = market.upperBound();

        // questionId must be a hash of all the values used to resolve a market, this way if an attacker tries to resolve a fake market by changing some value its questionId will not match the id of a valid market.
        bytes32 questionId = keccak256(abi.encode(questionsIds, numOutcomes, templateId, low, high));

        if (templateId == REALITY_SINGLE_SELECT_TEMPLATE) {
            resolveCategoricalMarket(questionId, questionsIds, numOutcomes);
            return;
        }

        if (templateId == REALITY_MULTI_SELECT_TEMPLATE) {
            resolveMultiCategoricalMarket(questionId, questionsIds, numOutcomes);
            return;
        }

        if (questionsIds.length > 1) {
            resolveMultiScalarMarket(questionId, questionsIds, numOutcomes);
            return;
        }

        resolveScalarMarket(questionId, questionsIds, low, high);
    }

    /// @dev Resolves to invalid if the answer is invalid or the result is greater than the amount of outcomes.
    /// @param questionId Conditional Tokens questionId.
    /// @param questionsIds Reality questions ids.
    /// @param numOutcomes The number of outcomes, excluding the INVALID_RESULT outcome.
    function resolveCategoricalMarket(
        bytes32 questionId,
        bytes32[] memory questionsIds,
        uint256 numOutcomes
    ) internal {
        uint256 answer = uint256(realitio.resultForOnceSettled(questionsIds[0]));
        uint256[] memory payouts = new uint256[](numOutcomes + 1);

        if (answer == uint256(INVALID_RESULT) || answer >= numOutcomes) {
            // the last outcome is INVALID_RESULT.
            payouts[numOutcomes] = 1;
        } else {
            payouts[answer] = 1;
        }

        conditionalTokens.reportPayouts(questionId, payouts);
    }

    /// @dev Resolves to invalid if the answer is invalid or all the results are zero.
    /// @param questionId Conditional Tokens questionId.
    /// @param questionsIds Reality questions ids.
    /// @param numOutcomes The number of outcomes, excluding the INVALID_RESULT outcome.
    function resolveMultiCategoricalMarket(
        bytes32 questionId,
        bytes32[] memory questionsIds,
        uint256 numOutcomes
    ) internal {
        uint256 answer = uint256(realitio.resultForOnceSettled(questionsIds[0]));
        uint256[] memory payouts = new uint256[](numOutcomes + 1);

        if (answer == uint256(INVALID_RESULT)) {
            // the last outcome is INVALID_RESULT.
            payouts[numOutcomes] = 1;
        } else {
            bool allZeroes = true;

            for (uint256 i = 0; i < numOutcomes; i++) {
                payouts[i] = (answer >> i) & 1;
                allZeroes = allZeroes && payouts[i] == 0;
            }

            if (allZeroes) {
                // invalid result.
                payouts[numOutcomes] = 1;
            }
        }

        conditionalTokens.reportPayouts(questionId, payouts);
    }

    /// @dev Resolves to invalid if the answer is invalid.
    /// @param questionId Conditional Tokens questionId.
    /// @param questionsIds Reality questions ids.
    /// @param low Lower bound.
    /// @param high Upper bound.
    function resolveScalarMarket(
        bytes32 questionId,
        bytes32[] memory questionsIds,
        uint256 low,
        uint256 high
    ) internal {
        uint256 answer = uint256(realitio.resultForOnceSettled(questionsIds[0]));
        uint256[] memory payouts = new uint256[](3);

        if (answer == uint256(INVALID_RESULT)) {
            // the last outcome is INVALID_RESULT.
            payouts[2] = 1;
        } else if (answer <= low) {
            payouts[0] = 1;
        } else if (answer >= high) {
            payouts[1] = 1;
        } else {
            payouts[0] = high - answer;
            payouts[1] = answer - low;
        }

        conditionalTokens.reportPayouts(questionId, payouts);
    }

    /// @dev If any individual result is invalid then the corresponding payout element is set to 0.
    /// @dev If all the elements of the payout vector are 0 or all are invalid, the market resolves to invalid.
    /// @param questionId Conditional Tokens questionId.
    /// @param questionsIds Reality questions ids.
    /// @param numOutcomes The number of outcomes, excluding the INVALID_RESULT outcome.
    function resolveMultiScalarMarket(
        bytes32 questionId,
        bytes32[] memory questionsIds,
        uint256 numOutcomes
    ) internal {
        uint256[] memory payouts = new uint256[](numOutcomes + 1);
        bool allZeroesOrInvalid = true;

        /*
         * We set maxPayout to a sufficiently large number for most possible outcomes that also avoids overflows in the following places:
         * https://github.com/gnosis/conditional-tokens-contracts/blob/master/contracts/ConditionalTokens.sol#L89
         * https://github.com/gnosis/conditional-tokens-contracts/blob/master/contracts/ConditionalTokens.sol#L242
         */
        uint256 maxPayout = 2 ** (256 / 2) - 1;

        for (uint256 i = 0; i < numOutcomes; i++) {
            payouts[i] = uint256(realitio.resultForOnceSettled(questionsIds[i]));

            if (payouts[i] == uint256(INVALID_RESULT)) {
                payouts[i] = 0;
            } else if (payouts[i] > maxPayout) {
                payouts[i] = maxPayout;
            }

            allZeroesOrInvalid = allZeroesOrInvalid && payouts[i] == 0;
        }

        if (allZeroesOrInvalid) {
            // invalid result.
            payouts[numOutcomes] = 1;
        }

        conditionalTokens.reportPayouts(questionId, payouts);
    }
}

/**
 *  @authors: [@xyzseer]
 *  @reviewers: [@nvm1410, @madhurMongia, @unknownunknown1, @mani99brar]
 *  @auditors: []
 *  @bounties: []
 *  @deployments: []
 */

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

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

/// @dev The Router contract replicates the main Conditional Tokens functions, but allowing to work with ERC20 outcomes instead of the ERC1155.
contract Router 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 collateralToken The address of the ERC20 used as collateral.
    /// @param market The Market to split.
    /// @param amount The amount of collateral to split.
    function splitPosition(IERC20 collateralToken, Market market, uint256 amount) public {
        if (market.parentCollectionId() == bytes32(0)) {
            // transfer the collateral tokens to the Router.
            collateralToken.transferFrom(msg.sender, address(this), amount);
        }
        _splitPosition(collateralToken, market, 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 collateralToken The address of the ERC20 used as collateral.
    /// @param market The Market to split.
    /// @param amount The amount of collateral to split.
    function _splitPosition(IERC20 collateralToken, Market market, uint256 amount) internal {
        bytes32 parentCollectionId = market.parentCollectionId();
        bytes32 conditionId = market.conditionId();

        uint256[] memory partition = getPartition(conditionalTokens.getOutcomeSlotCount(conditionId));

        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) = market.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);

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

            (IERC20 wrapped1155, bytes memory data) = market.wrappedOutcome(j);

            // 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 collateralToken The address of the ERC20 used as collateral.
    /// @param market The Market to merge.
    /// @param amount The amount of outcome tokens to merge.
    function mergePositions(IERC20 collateralToken, Market market, uint256 amount) public {
        _mergePositions(collateralToken, market, amount);

        if (market.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 collateralToken The address of the ERC20 used as collateral.
    /// @param market The Market to merge.
    /// @param amount The amount of outcome tokens to merge.
    function _mergePositions(IERC20 collateralToken, Market market, uint256 amount) internal {
        bytes32 parentCollectionId = market.parentCollectionId();
        bytes32 conditionId = market.conditionId();

        uint256[] memory partition = getPartition(conditionalTokens.getOutcomeSlotCount(conditionId));

        // we need to unwrap the outcome tokens because they will be burnt during the merge.

        for (uint256 j = 0; j < partition.length; j++) {
            uint256 tokenId = getTokenId(collateralToken, parentCollectionId, conditionId, partition[j]);

            (IERC20 wrapped1155, bytes memory data) = market.wrappedOutcome(j);

            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) = market.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 collateralToken The address of the ERC20 used as collateral.
    /// @param market The Market to redeem.
    /// @param outcomeIndexes The index of the outcomes to redeem.
    /// @param amounts Amount to redeem of each outcome.
    function redeemPositions(
        IERC20 collateralToken,
        Market market,
        uint256[] calldata outcomeIndexes,
        uint256[] calldata amounts
    ) public {
        bytes32 parentCollectionId = market.parentCollectionId();
        uint256 initialBalance;

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

        _redeemPositions(collateralToken, market, outcomeIndexes, amounts);

        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 collateralToken The address of the ERC20 used as collateral.
    /// @param market The Market to redeem.
    /// @param outcomeIndexes The index of the outcomes to redeem.
    /// @param amounts Amount to redeem of each outcome.
    function _redeemPositions(
        IERC20 collateralToken,
        Market market,
        uint256[] calldata outcomeIndexes,
        uint256[] calldata amounts
    ) internal {
        bytes32 parentCollectionId = market.parentCollectionId();
        bytes32 conditionId = market.conditionId();
        uint256 tokenId = 0;

        uint256[] memory indexSets = new uint256[](outcomeIndexes.length);

        for (uint256 j = 0; j < outcomeIndexes.length; j++) {
            indexSets[j] = 1 << outcomeIndexes[j];
            tokenId = getTokenId(collateralToken, parentCollectionId, conditionId, indexSets[j]);

            // first we need to unwrap the outcome tokens that will be redeemed.
            (IERC20 wrapped1155, bytes memory data) = market.wrappedOutcome(outcomeIndexes[j]);

            wrapped1155.transferFrom(msg.sender, address(this), amounts[j]);

            wrapped1155Factory.unwrap(address(conditionalTokens), tokenId, amounts[j], 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) = market.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");
            }
        }
    }

    /// @dev Returns a partition containing the full set of outcomes.
    /// @param size Number of outcome slots.
    /// @return The partition containing the full set of outcomes.
    function getPartition(uint256 size) internal pure returns (uint256[] memory) {
        uint256[] memory partition = new uint256[](size);

        for (uint256 i = 0; i < size; i++) {
            partition[i] = 1 << i;
        }

        return partition;
    }

    /// @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;
    }
}

{
  "compilationTarget": {
    "src/MainnetRouter.sol": "MainnetRouter"
  },
  "evmVersion": "paris",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs",
    "useLiteralContent": true
  },
  "optimizer": {
    "enabled": true,
    "runs": 100
  },
  "remappings": []
}