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

import "@openzeppelin/contracts/access/AccessControl.sol";

contract Access is AccessControl {
    bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");

    constructor() {
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(ADMIN_ROLE, msg.sender);
    }

    function transferOwnership(address newOwner) public onlyRole(DEFAULT_ADMIN_ROLE) {
        require(newOwner != address(0), "New owner cannot be zero address");

        _revokeRole(DEFAULT_ADMIN_ROLE, msg.sender);

        _grantRole(DEFAULT_ADMIN_ROLE, newOwner);
    }

    function addAdmin(address account) public onlyRole(DEFAULT_ADMIN_ROLE) {
        grantRole(ADMIN_ROLE, account);
    }

    function removeAdmin(address account) public onlyRole(DEFAULT_ADMIN_ROLE) {
        revokeRole(ADMIN_ROLE, account);
    }

    function isAdmin(address account) external view returns (bool) {
        return hasRole(ADMIN_ROLE, account);
    }

    function isOwner(address account) external view returns (bool) {
        return hasRole(DEFAULT_ADMIN_ROLE, account);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/AccessControl.sol)

pragma solidity ^0.8.20;

import {IAccessControl} from "./IAccessControl.sol";
import {Context} from "../utils/Context.sol";
import {ERC165} from "../utils/introspection/ERC165.sol";

/**
 * @dev Contract module that allows children to implement role-based access
 * control mechanisms. This is a lightweight version that doesn't allow enumerating role
 * members except through off-chain means by accessing the contract event logs. Some
 * applications may benefit from on-chain enumerability, for those cases see
 * {AccessControlEnumerable}.
 *
 * Roles are referred to by their `bytes32` identifier. These should be exposed
 * in the external API and be unique. The best way to achieve this is by
 * using `public constant` hash digests:
 *
 * ```solidity
 * bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
 * ```
 *
 * Roles can be used to represent a set of permissions. To restrict access to a
 * function call, use {hasRole}:
 *
 * ```solidity
 * function foo() public {
 *     require(hasRole(MY_ROLE, msg.sender));
 *     ...
 * }
 * ```
 *
 * Roles can be granted and revoked dynamically via the {grantRole} and
 * {revokeRole} functions. Each role has an associated admin role, and only
 * accounts that have a role's admin role can call {grantRole} and {revokeRole}.
 *
 * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
 * that only accounts with this role will be able to grant or revoke other
 * roles. More complex role relationships can be created by using
 * {_setRoleAdmin}.
 *
 * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
 * grant and revoke this role. Extra precautions should be taken to secure
 * accounts that have been granted it. We recommend using {AccessControlDefaultAdminRules}
 * to enforce additional security measures for this role.
 */
abstract contract AccessControl is Context, IAccessControl, ERC165 {
    struct RoleData {
        mapping(address account => bool) hasRole;
        bytes32 adminRole;
    }

    mapping(bytes32 role => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

    /**
     * @dev Modifier that checks that an account has a specific role. Reverts
     * with an {AccessControlUnauthorizedAccount} error including the required role.
     */
    modifier onlyRole(bytes32 role) {
        _checkRole(role);
        _;
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);
    }

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) public view virtual returns (bool) {
        return _roles[role].hasRole[account];
    }

    /**
     * @dev Reverts with an {AccessControlUnauthorizedAccount} error if `_msgSender()`
     * is missing `role`. Overriding this function changes the behavior of the {onlyRole} modifier.
     */
    function _checkRole(bytes32 role) internal view virtual {
        _checkRole(role, _msgSender());
    }

    /**
     * @dev Reverts with an {AccessControlUnauthorizedAccount} error if `account`
     * is missing `role`.
     */
    function _checkRole(bytes32 role, address account) internal view virtual {
        if (!hasRole(role, account)) {
            revert AccessControlUnauthorizedAccount(account, role);
        }
    }

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) public view virtual returns (bytes32) {
        return _roles[role].adminRole;
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     *
     * May emit a {RoleGranted} event.
     */
    function grantRole(bytes32 role, address account) public virtual onlyRole(getRoleAdmin(role)) {
        _grantRole(role, account);
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     *
     * May emit a {RoleRevoked} event.
     */
    function revokeRole(bytes32 role, address account) public virtual onlyRole(getRoleAdmin(role)) {
        _revokeRole(role, account);
    }

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been revoked `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `callerConfirmation`.
     *
     * May emit a {RoleRevoked} event.
     */
    function renounceRole(bytes32 role, address callerConfirmation) public virtual {
        if (callerConfirmation != _msgSender()) {
            revert AccessControlBadConfirmation();
        }

        _revokeRole(role, callerConfirmation);
    }

    /**
     * @dev Sets `adminRole` as ``role``'s admin role.
     *
     * Emits a {RoleAdminChanged} event.
     */
    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
        bytes32 previousAdminRole = getRoleAdmin(role);
        _roles[role].adminRole = adminRole;
        emit RoleAdminChanged(role, previousAdminRole, adminRole);
    }

    /**
     * @dev Attempts to grant `role` to `account` and returns a boolean indicating if `role` was granted.
     *
     * Internal function without access restriction.
     *
     * May emit a {RoleGranted} event.
     */
    function _grantRole(bytes32 role, address account) internal virtual returns (bool) {
        if (!hasRole(role, account)) {
            _roles[role].hasRole[account] = true;
            emit RoleGranted(role, account, _msgSender());
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Attempts to revoke `role` to `account` and returns a boolean indicating if `role` was revoked.
     *
     * Internal function without access restriction.
     *
     * May emit a {RoleRevoked} event.
     */
    function _revokeRole(bytes32 role, address account) internal virtual returns (bool) {
        if (hasRole(role, account)) {
            _roles[role].hasRole[account] = false;
            emit RoleRevoked(role, account, _msgSender());
            return true;
        } else {
            return false;
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

// 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) (access/IAccessControl.sol)

pragma solidity ^0.8.20;

/**
 * @dev External interface of AccessControl declared to support ERC-165 detection.
 */
interface IAccessControl {
    /**
     * @dev The `account` is missing a role.
     */
    error AccessControlUnauthorizedAccount(address account, bytes32 neededRole);

    /**
     * @dev The caller of a function is not the expected one.
     *
     * NOTE: Don't confuse with {AccessControlUnauthorizedAccount}.
     */
    error AccessControlBadConfirmation();

    /**
     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
     *
     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
     * {RoleAdminChanged} not being emitted signaling this.
     */
    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);

    /**
     * @dev Emitted when `account` is granted `role`.
     *
     * `sender` is the account that originated the contract call. This account bears the admin role (for the granted role).
     * Expected in cases where the role was granted using the internal {AccessControl-_grantRole}.
     */
    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Emitted when `account` is revoked `role`.
     *
     * `sender` is the account that originated the contract call:
     *   - if using `revokeRole`, it is the admin role bearer
     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
     */
    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) external view returns (bool);

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {AccessControl-_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) external view returns (bytes32);

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been granted `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `callerConfirmation`.
     */
    function renounceRole(bytes32 role, address callerConfirmation) external;
}

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

import { IERC20 } from "./IERC20.sol";
import { IConditionalTokens } from "./IConditionalTokens.sol";

interface ICPMM is IERC20 {
    event FPMMFundingAdded(address indexed funder, uint256[] amountsAdded, uint256 sharesMinted);
    event FPMMFundingRemoved(
        address indexed funder, uint256[] amountsRemoved, uint256 collateralRemovedFromFeePool, uint256 sharesBurnt
    );

    function conditionalTokens() external view returns (IConditionalTokens);

    function addFunding(uint256 addedFunds, uint256[] calldata distributionHint) external;
    function removeFunding(uint256 sharesToBurn) external;
    function withdrawFee(address account) external;

    function feesWithdrawableBy(address account) external view returns (uint256);

    function onERC1155Received(address operator, address from, uint256 id, uint256 value, bytes calldata data)
        external
        returns (bytes4);
    function onERC1155BatchReceived(
        address operator,
        address from,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external returns (bytes4);
}

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

import { IERC20 } from "./IERC20.sol";
import { ICPMM } from "./ICPMM.sol";
import { IConditionalTokens } from "./IConditionalTokens.sol";

interface ICPMMFactory {
    function createFixedProductMarketMaker(
        IConditionalTokens conditionalTokens,
        IERC20 collateralToken,
        bytes32[] calldata conditionIds,
        uint256 fee
    ) external returns (ICPMM);
}

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

import { IERC20 } from "./IERC20.sol";
import { IERC1155 } from "./IERC1155.sol";

interface IConditionalTokens is IERC1155 {
    /// Mapping key is an condition ID. Value represents numerators of the payout vector associated with the condition. This array is initialized with a length equal to the outcome slot count. E.g. Condition with 3 outcomes [A, B, C] and two of those correct [0.5, 0.5, 0]. In Ethereum there are no decimal values, so here, 0.5 is represented by fractions like 1/2 == 0.5. That's why we need numerator and denominator values. Payout numerators are also used as a check of initialization. If the numerators array is empty (has length zero), the condition was not created/prepared. See getOutcomeSlotCount.
    function payoutNumerators(bytes32) external returns (uint256[] memory);

    /// Denominator is also used for checking if the condition has been resolved. If the denominator is non-zero, then the condition has been resolved.
    function payoutDenominator(bytes32) external returns (uint256);

    /// @dev This function prepares a condition by initializing a payout vector associated with the condition.
    /// @param oracle The account assigned to report the result for the prepared condition.
    /// @param questionId An identifier for the question to be answered by the oracle.
    /// @param outcomeSlotCount The number of outcome slots which should be used for this condition. Must not exceed 256.
    function prepareCondition(address oracle, bytes32 questionId, uint256 outcomeSlotCount) external;

    /// @dev Called by the oracle for reporting results of conditions. Will set the payout vector for the condition with the ID ``keccak256(abi.encodePacked(oracle, questionId, outcomeSlotCount))``, where oracle is the message sender, questionId is one of the parameters of this function, and outcomeSlotCount is the length of the payouts parameter, which contains the payoutNumerators for each outcome slot of the condition.
    /// @param questionId The question ID the oracle is answering for
    /// @param payouts The oracle's answer
    function reportPayouts(bytes32 questionId, uint256[] calldata payouts) external;

    /// @dev This function splits a position. If splitting from the collateral, this contract will attempt to transfer `amount` collateral from the message sender to itself. Otherwise, this contract will burn `amount` stake held by the message sender in the position being split worth of EIP 1155 tokens. Regardless, if successful, `amount` stake will be minted in the split target positions. If any of the transfers, mints, or burns fail, the transaction will revert. The transaction will also revert if the given partition is trivial, invalid, or refers to more slots than the condition is prepared with.
    /// @param collateralToken The address of the positions' backing collateral token.
    /// @param parentCollectionId The ID of the outcome collections common to the position being split and the split target positions. May be null, in which only the collateral is shared.
    /// @param conditionId The ID of the condition to split on.
    /// @param partition An array of disjoint index sets representing a nontrivial partition of the outcome slots of the given condition. E.g. A|B and C but not A|B and B|C (is not disjoint). Each element's a number which, together with the condition, represents the outcome collection. E.g. 0b110 is A|B, 0b010 is B, etc.
    /// @param amount The amount of collateral or stake to split.
    function splitPosition(
        IERC20 collateralToken,
        bytes32 parentCollectionId,
        bytes32 conditionId,
        uint256[] calldata partition,
        uint256 amount
    ) external;

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

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

    /// @dev Gets the outcome slot count of a condition.
    /// @param conditionId ID of the condition.
    /// @return Number of outcome slots associated with a condition, or zero if condition has not been prepared yet.
    function getOutcomeSlotCount(bytes32 conditionId) external view returns (uint256);

    /// @dev Constructs a condition ID from an oracle, a question ID, and the outcome slot count for the question.
    /// @param oracle The account assigned to report the result for the prepared condition.
    /// @param questionId An identifier for the question to be answered by the oracle.
    /// @param outcomeSlotCount The number of outcome slots which should be used for this condition. Must not exceed 256.
    function getConditionId(address oracle, bytes32 questionId, uint256 outcomeSlotCount)
        external
        pure
        returns (bytes32);

    /// @dev Constructs an outcome collection ID from a parent collection and an outcome collection.
    /// @param parentCollectionId Collection ID of the parent outcome collection, or bytes32(0) if there's no parent.
    /// @param conditionId Condition ID of the outcome collection to combine with the parent outcome collection.
    /// @param indexSet Index set of the outcome collection to combine with the parent outcome collection.
    function getCollectionId(bytes32 parentCollectionId, bytes32 conditionId, uint256 indexSet)
        external
        view
        returns (bytes32);

    /// @dev Constructs a position ID from a collateral token and an outcome collection. These IDs are used as the ERC-1155 ID for this contract.
    /// @param collateralToken Collateral token which backs the position.
    /// @param collectionId ID of the outcome collection associated with this position.
    function getPositionId(IERC20 collateralToken, bytes32 collectionId) external pure returns (uint256);
}

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

pragma solidity ^0.8.20;

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

/**
 * @dev Required interface of an ERC-1155 compliant contract, as defined in the
 * https://eips.ethereum.org/EIPS/eip-1155[ERC].
 */
interface IERC1155 is IERC165 {
    /**
     * @dev Emitted when `value` amount of tokens of type `id` are transferred from `from` to `to` by `operator`.
     */
    event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);

    /**
     * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all
     * transfers.
     */
    event TransferBatch(
        address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] values
    );

    /**
     * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to
     * `approved`.
     */
    event ApprovalForAll(address indexed account, address indexed operator, bool approved);

    /**
     * @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI.
     *
     * If an {URI} event was emitted for `id`, the standard
     * https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value
     * returned by {IERC1155MetadataURI-uri}.
     */
    event URI(string value, uint256 indexed id);

    /**
     * @dev Returns the value of tokens of token type `id` owned by `account`.
     */
    function balanceOf(address account, uint256 id) external view returns (uint256);

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}.
     *
     * Requirements:
     *
     * - `accounts` and `ids` must have the same length.
     */
    function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids)
        external
        view
        returns (uint256[] memory);

    /**
     * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`,
     *
     * Emits an {ApprovalForAll} event.
     *
     * Requirements:
     *
     * - `operator` cannot be the zero address.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns true if `operator` is approved to transfer ``account``'s tokens.
     *
     * See {setApprovalForAll}.
     */
    function isApprovedForAll(address account, address operator) external view returns (bool);

    /**
     * @dev Transfers a `value` amount of tokens of type `id` from `from` to `to`.
     *
     * WARNING: This function can potentially allow a reentrancy attack when transferring tokens
     * to an untrusted contract, when invoking {onERC1155Received} on the receiver.
     * Ensure to follow the checks-effects-interactions pattern and consider employing
     * reentrancy guards when interacting with untrusted contracts.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}.
     * - `from` must have a balance of tokens of type `id` of at least `value` amount.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes calldata data) external;

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}.
     *
     * WARNING: This function can potentially allow a reentrancy attack when transferring tokens
     * to an untrusted contract, when invoking {onERC1155BatchReceived} on the receiver.
     * Ensure to follow the checks-effects-interactions pattern and consider employing
     * reentrancy guards when interacting with untrusted contracts.
     *
     * Emits either a {TransferSingle} or a {TransferBatch} event, depending on the length of the array arguments.
     *
     * Requirements:
     *
     * - `ids` and `values` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external;
}

// 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) (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);
}

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

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC-20 standard as defined in the ERC.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the value of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 value) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}

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

interface ILimitlessAgentVaultV1EE {
    error InsufficientBalance();
    error TransferFailed();
    error ApprovalFailed();
    error InvalidCollateral();
    error InvalidAmount();

    event CollateralAdded(address indexed collateralToken);
    event CollateralRemoved(address indexed collateralToken);
    event EmergencyErc20Withdraw(address indexed erc20, address indexed destination, uint256 amount);
    event EmergencyEtherWithdraw(address indexed destination, uint256 amount);
    event EmergencyConditionalTokensWithdraw(
        address indexed conditionalTokens, uint256[] positionIds, address indexed destination
    );
    event VaultFundingAdded(
        address indexed collateral, address indexed cpmm, uint256 addedFunds, uint256[] distributionHint
    );
    event VaultFundingRemoved(address indexed cpmm, uint256 sharesBurned);
    event VaultFeesWithdrawn(address indexed cpmm, uint256 amount);
    event VaultPositionSplit(address indexed conditionalTokens, bytes32 conditionId, uint256 amount);
    event VaultPositionsMerged(address indexed conditionalTokens, bytes32 conditionId, uint256 amount);
    event VaultPositionsRedeemed(
        address indexed conditionalTokens, address indexed collateralToken, bytes32 conditionId
    );
}

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

struct QuestionData {
    uint256 requestTimestamp;
    int64 price;
    int32 expo;
    uint256 confAge;
    uint256 deadline;
    uint256 emergencyResolutionTimestamp;
    bytes32 priceFeedId;
    bool initialized;
    bool resolved;
    address creator;
    int16 winningIndex;
    int64 settledPrice;
    int32 settledExpo;
    uint256 publishTime;
}

interface ILimitlessPriceOracleV1EE {
    error NotInitialized();
    error AlreadyInitialized();
    error NotPaused();
    error Paused();
    error NotFlagged();
    error NotReadyToResolve();
    error Resolved();
    error Flagged();
    error DeadlineNotPassed();
    error SafetyPeriodPassed();
    error SafetyPeriodNotPassed();
    error PriceOutdated();
    error PriceNotAvailable();
    error InvalidExpo();
    error InvalidPrice();
    error InvalidPayoutsPrice();
    error InvalidPayouts();
    error InvalidDeadline();
    error InvalidPriceFeed();

    event QuestionInitialized(
        bytes32 indexed questionId,
        address indexed creator,
        bytes32 indexed priceFeedId,
        uint256 requestTimestamp,
        int64 price,
        int32 expo,
        uint256 confTime,
        uint256 deadline
    );

    event QuestionFlagged(bytes32 indexed questionId);
    event QuestionUnflagged(bytes32 indexed questionId);
    event QuestionReset(bytes32 indexed questionId);
    event QuestionResolved(
        bytes32 indexed questionId, int256 indexed settledPrice, int32 expo, uint256[] payouts, uint256 publishTime
    );
    event QuestionEmergencyResolved(bytes32 indexed questionId, uint256[] payouts);
}

interface ILimitlessPriceOracleV1 {
    function initialize(
        bytes32 questionID,
        bytes32 priceFeedID,
        int64 price,
        int32 expo,
        uint256 confAge,
        uint256 deadline
    ) external;
}

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

import { IConditionalTokens } from "./interfaces/IConditionalTokens.sol";
import { IERC20 } from "./interfaces/IERC20.sol";
import { ICPMM } from "./interfaces/ICPMM.sol";
import { ICPMMFactory } from "./interfaces/ICPMMFactory.sol";
import { ILimitlessPriceOracleV1 } from "./interfaces/ILimitlessPriceOracleV1.sol";
import { ILimitlessAgentVaultV1EE } from "./interfaces/ILimitlessAgentVaultV1.sol";

import { ERC1155Holder } from "@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol";
import { AccessControl } from "@openzeppelin/contracts/access/AccessControl.sol";

import { Access } from "./mixins/Access.sol";

/**
 * @title LimitlessAgentVaultV1
 * @dev A vault contract that manages conditional tokens, market making positions, and collateral
 * for prediction markets. This contract integrates with the Conditional Tokens Framework and
 * supports various operations including funding management, position splitting/merging, and
 * emergency withdrawals.
 *
 * Key Features:
 * - Collateral management for prediction markets
 * - Integration with Conditional Tokens Framework
 * - Market making position management
 * - Emergency withdrawal capabilities
 * - Advanced position operations (split, merge, redeem)
 */
contract LimitlessAgentVaultV1 is ILimitlessAgentVaultV1EE, ERC1155Holder, Access {
    /// @notice Mapping of approved collateral tokens
    mapping(address => bool) public collaterals;

    /*///////////////////////////////////////////////////////////////////
                                EXTERNAL FUNCTIONS
    //////////////////////////////////////////////////////////////////*/

    /**
     * @notice Adds a new collateral token to the approved list
     * @param collateralToken Address of the collateral token to add
     */
    function addCollateral(address collateralToken) external onlyRole(DEFAULT_ADMIN_ROLE) {
        collaterals[collateralToken] = true;
        emit CollateralAdded(collateralToken);
    }

    /**
     * @notice Removes a collateral token from the approved list
     * @param collateralToken Address of the collateral token to remove
     */
    function removeCollateral(address collateralToken) external onlyRole(DEFAULT_ADMIN_ROLE) {
        collaterals[collateralToken] = false;
        emit CollateralRemoved(collateralToken);
    }

    /**
     * @notice Adds funding to a CPMM market
     * @param collateralToken Address of the collateral token
     * @param cpmm Address of the CPMM market
     * @param addedFunds Amount of funds to add
     * @param distributionHint Distribution hint for the market maker
     */
    function addFunding(address collateralToken, address cpmm, uint256 addedFunds, uint256[] calldata distributionHint)
        external
        onlyRole(ADMIN_ROLE)
    {
        if (!collaterals[collateralToken]) revert InvalidCollateral();
        _addFunding(collateralToken, cpmm, addedFunds, distributionHint);
    }

    /**
     * @notice Initializes a question and adds funding to its market
     * @param collateralToken Address of the collateral token
     * @param oracle Address of the price oracle
     * @param questionId Unique identifier for the question
     * @param priceFeedID Identifier for the price feed
     * @param targetPrice Target price for the market
     * @param expo Price exponent
     * @param cpmm Address of the CPMM market
     * @param confAge Confidence age for price validation
     * @param deadline Deadline for market resolution
     * @param addedFunds Amount of funds to add
     * @param distributionHint Distribution hint for the market maker
     */
    function initQuestionAndAddFunding(
        address collateralToken,
        address oracle,
        bytes32 questionId,
        bytes32 priceFeedID,
        int64 targetPrice,
        int32 expo,
        address cpmm,
        uint256 confAge,
        uint256 deadline,
        uint256 addedFunds,
        uint256[] calldata distributionHint
    ) external onlyRole(ADMIN_ROLE) {
        if (!collaterals[collateralToken]) revert InvalidCollateral();

        ILimitlessPriceOracleV1 priceOracle = ILimitlessPriceOracleV1(oracle);
        priceOracle.initialize(questionId, priceFeedID, targetPrice, expo, confAge, deadline);

        _addFunding(collateralToken, address(cpmm), addedFunds, distributionHint);
    }

    /**
     * @notice Removes funding from a CPMM market
     * @param cpmm Address of the CPMM market
     * @param sharesToBurn Number of shares to burn
     */
    function removeFunding(address cpmm, uint256 sharesToBurn) external onlyRole(ADMIN_ROLE) {
        _removeFunding(cpmm, sharesToBurn);
    }

    /**
     * @notice Removes funding and redeems positions in one transaction
     * @param conditionalTokens Address of the conditional tokens contract
     * @param collateralToken Address of the collateral token
     * @param cpmm Address of the CPMM market
     * @param sharesToBurn Number of shares to burn
     * @param parentCollectionId Parent collection identifier
     * @param conditionId Condition identifier
     * @param indexSets Array of index sets to redeem
     */
    function removeFundingAndRedeemPositions(
        address conditionalTokens,
        address collateralToken,
        address cpmm,
        uint256 sharesToBurn,
        bytes32 parentCollectionId,
        bytes32 conditionId,
        uint256[] calldata indexSets
    ) external onlyRole(ADMIN_ROLE) {
        if (!collaterals[collateralToken]) revert InvalidCollateral();

        _removeFunding(cpmm, sharesToBurn);
        _redeemPositions(conditionalTokens, collateralToken, parentCollectionId, conditionId, indexSets);
    }

    /**
     * @notice Withdraws accumulated fees from a CPMM market
     * @param cpmm Address of the CPMM market
     */
    function withdrawFees(address cpmm) external onlyRole(ADMIN_ROLE) {
        ICPMM(cpmm).withdrawFee(address(this));
    }

    /**
     * @notice Splits a position into multiple outcome tokens
     * @param conditionalTokens Address of the conditional tokens contract
     * @param collateralToken Address of the collateral token
     * @param parentCollectionId Parent collection identifier
     * @param conditionId Condition identifier
     * @param partition Array defining the partition
     * @param amount Amount of tokens to split
     */
    function splitPosition(
        address conditionalTokens,
        address collateralToken,
        bytes32 parentCollectionId,
        bytes32 conditionId,
        uint256[] calldata partition,
        uint256 amount
    ) external onlyRole(ADMIN_ROLE) {
        if (amount == 0) revert InvalidAmount();

        IConditionalTokens ctf = IConditionalTokens(conditionalTokens);

        if (!collaterals[collateralToken]) revert InvalidCollateral();
        IERC20 collateral = IERC20(collateralToken);
        if (amount > collateral.balanceOf(address(this))) revert InsufficientBalance();
        if (!collateral.approve(conditionalTokens, amount)) revert ApprovalFailed();
        ctf.splitPosition(collateral, parentCollectionId, conditionId, partition, amount);

        emit VaultPositionSplit(conditionalTokens, conditionId, amount);
    }

    /**
     * @notice Merges multiple outcome tokens back into a position
     * @param conditionalTokens Address of the conditional tokens contract
     * @param collateralToken Address of the collateral token
     * @param parentCollectionId Parent collection identifier
     * @param conditionId Condition identifier
     * @param partition Array defining the partition
     * @param amount Amount of tokens to merge
     */
    function mergePositions(
        address conditionalTokens,
        address collateralToken,
        bytes32 parentCollectionId,
        bytes32 conditionId,
        uint256[] calldata partition,
        uint256 amount
    ) external onlyRole(ADMIN_ROLE) {
        if (!collaterals[collateralToken]) revert InvalidCollateral();
        IConditionalTokens ctf = IConditionalTokens(conditionalTokens);
        IERC20 collateral = IERC20(collateralToken);

        ctf.setApprovalForAll(conditionalTokens, true);
        ctf.mergePositions(collateral, parentCollectionId, conditionId, partition, amount);

        emit VaultPositionsMerged(conditionalTokens, conditionId, amount);
    }

    /**
     * @notice Redeems positions for collateral tokens
     * @param conditionalTokens Address of the conditional tokens contract
     * @param collateralToken Address of the collateral token
     * @param parentCollectionId Parent collection identifier
     * @param conditionId Condition identifier
     * @param indexSets Array of index sets to redeem
     */
    function redeemPositions(
        address conditionalTokens,
        address collateralToken,
        bytes32 parentCollectionId,
        bytes32 conditionId,
        uint256[] calldata indexSets
    ) external onlyRole(ADMIN_ROLE) {
        if (!collaterals[collateralToken]) revert InvalidCollateral();

        _redeemPositions(conditionalTokens, collateralToken, parentCollectionId, conditionId, indexSets);
    }

    /**
     * @notice Emergency withdrawal of ERC20 tokens
     * @param erc20 Address of the ERC20 token to withdraw
     * @param destination Address to send the tokens to
     */
    function emergencyErc20TokenWithdraw(address erc20, address destination) external onlyRole(DEFAULT_ADMIN_ROLE) {
        IERC20 token = IERC20(erc20);
        if (!token.transfer(destination, token.balanceOf(address(this)))) revert TransferFailed();

        emit EmergencyErc20Withdraw(erc20, destination, token.balanceOf(address(this)));
    }

    /**
     * @notice Emergency withdrawal of conditional tokens
     * @param conditionalTokens Address of the conditional tokens contract
     * @param positionIds Array of position IDs to withdraw
     * @param destination Address to send the tokens to
     */
    function emergencyConditionalTokensWithdraw(
        address conditionalTokens,
        uint256[] calldata positionIds,
        address destination
    ) external onlyRole(DEFAULT_ADMIN_ROLE) {
        IConditionalTokens ctf = IConditionalTokens(conditionalTokens);
        ctf.setApprovalForAll(address(this), true);

        for (uint256 i = 0; i < positionIds.length; i++) {
            ctf.safeTransferFrom(
                address(this), destination, positionIds[i], ctf.balanceOf(address(this), positionIds[i]), ""
            );
        }

        emit EmergencyConditionalTokensWithdraw(conditionalTokens, positionIds, destination);
    }

    /*///////////////////////////////////////////////////////////////////
                                VIEW FUNCTIONS
    //////////////////////////////////////////////////////////////////*/

    /**
     * @notice Gets the balance and position ID for a specific position
     * @param conditionalTokens Address of the conditional tokens contract
     * @param collateralToken Address of the collateral token
     * @param parentCollectionId Parent collection identifier
     * @param conditionId Condition identifier
     * @param indexSet Index set of the position
     * @return balance Balance of the position
     * @return positionId ID of the position
     */
    function positionBalance(
        address conditionalTokens,
        address collateralToken,
        bytes32 parentCollectionId,
        bytes32 conditionId,
        uint256 indexSet
    ) external view returns (uint256, uint256) {
        IConditionalTokens ctf = IConditionalTokens(conditionalTokens);
        IERC20 collateral = IERC20(collateralToken);

        bytes32 collectionId = ctf.getCollectionId(parentCollectionId, conditionId, indexSet);
        uint256 positionId = ctf.getPositionId(collateral, collectionId);

        return (ctf.balanceOf(address(this), positionId), positionId);
    }

    /**
     * @notice Gets the balance for a specific position ID
     * @param conditionalTokens Address of the conditional tokens contract
     * @param positionId ID of the position
     * @return balance Balance of the position
     * @return id ID of the position
     */
    function positionBalanceById(address conditionalTokens, uint256 positionId)
        external
        view
        returns (uint256, uint256)
    {
        IConditionalTokens ctf = IConditionalTokens(conditionalTokens);
        return (ctf.balanceOf(address(this), positionId), positionId);
    }

    /**
     * @notice Gets the balance of shares in a CPMM market
     * @param cpmm Address of the CPMM market
     * @return Balance of shares
     */
    function sharesBalance(address cpmm) external view returns (uint256) {
        return ICPMM(cpmm).balanceOf(address(this));
    }

    /**
     * @notice Gets the amount of withdrawable fees from a CPMM market
     * @param cpmm Address of the CPMM market
     * @return Amount of withdrawable fees
     */
    function feesWithdrawable(address cpmm) external view returns (uint256) {
        return ICPMM(cpmm).feesWithdrawableBy(address(this));
    }

    /**
     * @notice Checks if the contract supports a given interface
     * @param interfaceId Interface identifier to check
     * @return bool True if the interface is supported
     */
    function supportsInterface(bytes4 interfaceId)
        public
        view
        virtual
        override(AccessControl, ERC1155Holder)
        returns (bool)
    {
        return super.supportsInterface(interfaceId);
    }

    /*///////////////////////////////////////////////////////////////////
                                INTERNAL FUNCTIONS
    //////////////////////////////////////////////////////////////////*/

    function _addFunding(address collateral, address cpmm, uint256 addedFunds, uint256[] calldata distributionHint)
        internal
    {
        IERC20(collateral).approve(cpmm, addedFunds);
        ICPMM(cpmm).addFunding(addedFunds, distributionHint);

        emit VaultFundingAdded(collateral, cpmm, addedFunds, distributionHint);
    }

    function _removeFunding(address cpmm, uint256 sharesToBurn) internal {
        ICPMM(cpmm).approve(address(cpmm), sharesToBurn);
        ICPMM(cpmm).removeFunding(sharesToBurn);

        emit VaultFundingRemoved(cpmm, sharesToBurn);
    }

    function _redeemPositions(
        address conditionalTokens,
        address collateralToken,
        bytes32 parentCollectionId,
        bytes32 conditionId,
        uint256[] calldata indexSets
    ) internal {
        IConditionalTokens ctf = IConditionalTokens(conditionalTokens);
        IERC20 collateral = IERC20(collateralToken);
        ctf.setApprovalForAll(conditionalTokens, true);
        ctf.redeemPositions(collateral, parentCollectionId, conditionId, indexSets);

        emit VaultPositionsRedeemed(conditionalTokens, collateralToken, conditionId);
    }
}

{
  "compilationTarget": {
    "src/LimitlessAgentVaultV1.sol": "LimitlessAgentVaultV1"
  },
  "evmVersion": "paris",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": [
    ":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
    ":ds-test/=lib/openzeppelin-contracts/lib/forge-std/lib/ds-test/src/",
    ":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
    ":forge-std/=lib/forge-std/src/",
    ":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/",
    ":openzeppelin-contracts/=lib/openzeppelin-contracts/"
  ]
}