polkamarkets-js 3.2.0 → 3.3.1

package/contracts/PredictionMarketV3_4Bad.sol

@@ -1,1487 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.26;
-
-// openzeppelin upgradeable imports
-import "@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardUpgradeable.sol";
-import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
-import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
-import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
-
-// openzeppelin non-upgradeable imports (for interfaces)
-import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
-
-// local imports
-import "./IFantasyERC20.sol";
-import "./IRealityETH_ERC20.sol";
-import "./IPredictionMarketV3Manager.sol";
-import "./IWETH.sol";
-
-library CeilDivBad {
-  // calculates ceil(x/y)
-  function ceildiv(uint256 x, uint256 y) internal pure returns (uint256) {
-    if (x > 0) return ((x - 1) / y) + 1;
-    return 0;
-  }
-}
-
-/// @title Market Contract Factory
-contract PredictionMarketV3_4Bad is Initializable, ReentrancyGuardUpgradeable, OwnableUpgradeable, UUPSUpgradeable {
-  using SafeERC20 for IERC20;
-  using CeilDivBad for uint256;
-
-  // ------ Events ------
-
-  event MarketCreated(
-    address indexed user,
-    uint256 indexed marketId,
-    uint256 outcomes,
-    string question,
-    string image,
-    IERC20 token
-  );
-
-  event MarketActionTx(
-    address indexed user,
-    MarketAction indexed action,
-    uint256 indexed marketId,
-    uint256 outcomeId,
-    uint256 shares,
-    uint256 value,
-    uint256 timestamp
-  );
-
-  event Referral(
-    address indexed user,
-    uint256 indexed marketId,
-    string code,
-    MarketAction action,
-    uint256 outcomeId,
-    uint256 value,
-    uint256 timestamp
-  );
-
-  event MarketOutcomeShares(uint256 indexed marketId, uint256 timestamp, uint256[] outcomeShares, uint256 liquidity);
-
-  event MarketOutcomePrice(uint256 indexed marketId, uint256 indexed outcomeId, uint256 value, uint256 timestamp);
-
-  event MarketLiquidity(
-    uint256 indexed marketId,
-    uint256 value, // total liquidity
-    uint256 price, // value of one liquidity share; max: 1 (even odds situation)
-    uint256 timestamp
-  );
-
-  event MarketResolved(
-    address indexed user,
-    uint256 indexed marketId,
-    uint256 outcomeId,
-    uint256 timestamp,
-    bool admin
-  );
-
-  event MarketPaused(address indexed user, uint256 indexed marketId, bool paused, uint256 timestamp);
-
-  event MarketCloseDateEdited(
-    address indexed user,
-    uint256 indexed marketId,
-    uint256 closesAtTimestamp,
-    uint256 timestamp
-  );
-
-  event AllowedManagerSet(address indexed manager, bool allowed);
-
-  event Paused(bool paused, address indexed user);
-
-  // ------ Events End ------
-
-  uint256 private constant MAX_UINT_256 = type(uint256).max;
-
-  uint256 private constant ONE = 10**18;
-
-  uint256 public constant MAX_OUTCOMES = 2**5;
-
-  uint256 public constant MAX_FEE = 5 * 10**16; // 5%
-
-  uint256 public constant MINIMUM_REALITIO_TIMEOUT = 3600; // 1 hour
-
-  enum MarketState {
-    open,
-    closed,
-    resolved
-  }
-  enum MarketAction {
-    buy,
-    sell,
-    addLiquidity,
-    removeLiquidity,
-    claimWinnings,
-    claimLiquidity,
-    claimFees,
-    claimVoided
-  }
-
-  struct Market {
-    // market details
-    uint256 closesAtTimestamp;
-    uint256 balance; // total stake
-    uint256 liquidity; // stake held
-    uint256 sharesAvailable; // shares held (all outcomes)
-    mapping(address user => uint256 shares) liquidityShares;
-    mapping(address user => bool claimed) liquidityClaims; // wether user has claimed liquidity earnings
-    MarketState state; // resolution variables
-    MarketResolution resolution; // fees
-    MarketFees fees;
-    // market outcomes
-    uint256 outcomeCount;
-    mapping(uint256 outcomeId => MarketOutcome outcome) outcomes;
-    IERC20 token; // ERC20 token market will use for trading
-    IPredictionMarketV3Manager manager; // manager contract
-    address creator; // market creator
-    bool paused; // market paused, no trading allowed
-  }
-
-  struct Fees {
-    uint256 fee; // fee % taken from every transaction
-    uint256 treasuryFee; // fee % taken from every transaction to a treasury address
-    uint256 distributorFee; // fee % taken from every transaction to a distributor address
-  }
-
-  struct MarketFees {
-    uint256 poolWeight; // internal var used to ensure pro-rate fee distribution
-    mapping(address user => uint256 claimed) claimed;
-    address treasury; // address to send treasury fees to
-    address distributor; // fee % taken from every transaction to a treasury address
-    Fees buyFees; // fees for buy transactions
-    Fees sellFees; // fees for sell transactions
-  }
-
-  struct MarketResolution {
-    bool resolved;
-    IRealityETH_ERC20 realitio;
-    uint256 outcomeId;
-    bytes32 questionId; // realitio questionId
-    // realitio
-    uint256 realitioTimeout;
-  }
-
-  struct MarketOutcome {
-    uint256 marketId;
-    uint256 id;
-    Shares shares;
-  }
-
-  struct Shares {
-    uint256 total; // number of shares
-    uint256 available; // available shares
-    mapping(address user => uint256 shares) holders;
-    mapping(address user => bool winningsClaimed) claims; // wether user has claimed winnings
-    mapping(address user => bool voidedClaimed) voidedClaims; // wether user has claimed voided market shares
-  }
-
-  struct CreateMarketDescription {
-    uint256 value;
-    uint32 closesAt;
-    uint256 outcomes;
-    IERC20 token;
-    uint256[] distribution;
-    string question;
-    string image;
-    address arbitrator;
-    Fees buyFees;
-    Fees sellFees;
-    address treasury;
-    address distributor;
-    uint32 realitioTimeout;
-    IPredictionMarketV3Manager manager;
-  }
-
-  uint256 public testVarInTheBeginning;
-  uint256[] public testVarInTheBeginningArray;
-
-  uint256[] marketIds;
-  mapping(uint256 marketId => Market market) markets;
-  uint256 public marketIndex;
-  mapping(address manager => bool allowed) allowedManagers;
-
-  // weth configs
-  IWETH public WETH;
-
-  bool public paused;
-
-  // ------ Modifiers ------
-
-  modifier isMarket(uint256 marketId) {
-    require(marketId < marketIndex, "!m");
-    _;
-  }
-
-  modifier timeTransitions(uint256 marketId) {
-    if (block.timestamp > markets[marketId].closesAtTimestamp && markets[marketId].state == MarketState.open) {
-      _nextState(marketId);
-    }
-    _;
-  }
-
-  modifier atState(uint256 marketId, MarketState state) {
-    require(markets[marketId].state == state, "!ms");
-    _;
-  }
-
-  modifier notAtState(uint256 marketId, MarketState state) {
-    require(markets[marketId].state != state, "!ms");
-    _;
-  }
-
-  modifier whenNotPaused() {
-    require(!paused, "!p");
-    _;
-  }
-
-  modifier whenPaused() {
-    require(paused, "!p");
-    _;
-  }
-
-  modifier marketNotPaused(uint256 marketId) {
-    require(!paused, "p");
-    require(!markets[marketId].paused, "mp");
-    _;
-  }
-
-  modifier marketPaused(uint256 marketId) {
-    require(markets[marketId].paused, "!mp");
-    _;
-  }
-
-  modifier transitionNext(uint256 marketId) {
-    _;
-    _nextState(marketId);
-  }
-
-  modifier transitionLast(uint256 marketId) {
-    _;
-    _lastState(marketId);
-  }
-
-  modifier isWETHMarket(uint256 marketId) {
-    require(address(WETH) != address(0), "w0");
-    require(address(markets[marketId].token) == address(WETH), "!w");
-    _;
-  }
-
-  // ------ Modifiers End ------
-
-  /// @custom:oz-upgrades-unsafe-allow constructor
-  constructor() {
-    _disableInitializers();
-  }
-
-  /// @dev Initialize the contract - replaces constructor for upgradeable contracts
-  function initialize(IWETH _WETH, address initialOwner) public initializer {
-    __ReentrancyGuard_init();
-    __Ownable_init(initialOwner);
-    __UUPSUpgradeable_init();
-
-    WETH = _WETH;
-  }
-
-  receive() external payable {
-    assert(msg.sender == address(WETH)); // only accept ETH via fallback from the WETH contract
-  }
-
-  // ------ Core Functions ------
-
-  /// @dev for internal use only, validates the market fees and throws if they are not valid
-  function _validateFees(Fees memory fees) private pure {
-    require(fees.fee <= MAX_FEE, "f>5");
-    require(fees.treasuryFee <= MAX_FEE, "tf>5");
-    require(fees.distributorFee <= MAX_FEE, "df>5");
-  }
-
-  /// @dev Creates a market, initializes the outcome shares pool and submits a question in Realitio
-  function _createMarket(CreateMarketDescription memory desc) private returns (uint256 marketId) {
-    marketId = marketIndex;
-    marketIds.push(marketId);
-
-    Market storage market = markets[marketId];
-
-    IRealityETH_ERC20 realitio = IRealityETH_ERC20(desc.manager.getERC20RealitioAddress(desc.token));
-
-    require(desc.value > 0, "v0");
-    require(desc.closesAt > block.timestamp, "c<n");
-    require(desc.arbitrator != address(0), "a0");
-    require(desc.outcomes > 0 && desc.outcomes <= MAX_OUTCOMES, "!oc");
-    require(address(realitio) != address(0), "r0");
-    require(desc.realitioTimeout >= MINIMUM_REALITIO_TIMEOUT, "rt<1h");
-    require(allowedManagers[address(desc.manager)], "!am");
-    require(desc.manager.isAllowedToCreateMarket(desc.token, msg.sender), "m!=a");
-
-    market.token = desc.token;
-    market.closesAtTimestamp = desc.closesAt;
-    market.state = MarketState.open;
-
-    // setting up fees
-    _validateFees(desc.buyFees);
-    market.fees.buyFees = desc.buyFees;
-    _validateFees(desc.sellFees);
-    market.fees.sellFees = desc.sellFees;
-
-    market.fees.treasury = desc.treasury;
-    market.fees.distributor = desc.distributor;
-    // setting intial value to an integer that does not map to any outcomeId
-    market.resolution.outcomeId = MAX_UINT_256;
-    market.outcomeCount = desc.outcomes;
-
-    // creating question in realitio
-    market.resolution.questionId = realitio.askQuestionERC20(
-      2,
-      desc.question,
-      desc.arbitrator,
-      desc.realitioTimeout,
-      desc.closesAt,
-      0,
-      0
-    );
-    market.resolution.realitio = realitio;
-    market.resolution.realitioTimeout = desc.realitioTimeout;
-    market.manager = desc.manager;
-    market.creator = msg.sender;
-
-    _addLiquidity(marketId, desc.value, desc.distribution);
-
-    // emiting initial price events
-    _emitMarketActionEvents(marketId);
-    emit MarketCreated(msg.sender, marketId, desc.outcomes, desc.question, desc.image, desc.token);
-
-    // incrementing market array index
-    marketIndex += 1;
-  }
-
-  function createMarket(CreateMarketDescription calldata desc) external nonReentrant returns (uint256 marketId) {
-    marketId = _createMarket(
-      CreateMarketDescription({
-        value: desc.value,
-        closesAt: desc.closesAt,
-        outcomes: desc.outcomes,
-        token: desc.token,
-        distribution: desc.distribution,
-        question: desc.question,
-        image: desc.image,
-        arbitrator: desc.arbitrator,
-        buyFees: desc.buyFees,
-        sellFees: desc.sellFees,
-        treasury: desc.treasury,
-        distributor: desc.distributor,
-        realitioTimeout: desc.realitioTimeout,
-        manager: desc.manager
-      })
-    );
-    // transferring funds
-    desc.token.safeTransferFrom(msg.sender, address(this), desc.value);
-  }
-
-  function mintAndCreateMarket(CreateMarketDescription calldata desc) external nonReentrant returns (uint256 marketId) {
-    // mint the amount of tokens to the user
-    IFantasyERC20(address(desc.token)).mint(msg.sender, desc.value);
-
-    marketId = _createMarket(desc);
-    // transferring funds
-    desc.token.safeTransferFrom(msg.sender, address(this), desc.value);
-
-    return marketId;
-  }
-
-  /// @dev Calculates the number of shares bought with "amount" balance
-  function calcBuyAmount(
-    uint256 amount,
-    uint256 marketId,
-    uint256 outcomeId
-  ) public view returns (uint256) {
-    Market storage market = markets[marketId];
-    require(outcomeId < market.outcomeCount, "!o");
-
-    uint256[] memory outcomesShares = getMarketOutcomesShares(marketId);
-    uint256 fee = getMarketFee(marketId);
-    uint256 amountMinusFees = amount - ((amount * fee) / ONE);
-    uint256 buyTokenPoolBalance = outcomesShares[outcomeId];
-    uint256 endingOutcomeBalance = buyTokenPoolBalance * ONE;
-    for (uint256 i; i < market.outcomeCount; ++i) {
-      if (i != outcomeId) {
-        uint256 outcomeShares = outcomesShares[i];
-        endingOutcomeBalance = (endingOutcomeBalance * outcomeShares).ceildiv(outcomeShares + amountMinusFees);
-      }
-    }
-    require(endingOutcomeBalance > 0, "b0");
-
-    return buyTokenPoolBalance + amountMinusFees - (endingOutcomeBalance.ceildiv(ONE));
-  }
-
-  /// @dev Calculates the number of shares needed to be sold in order to receive "amount" in balance
-  function calcSellAmount(
-    uint256 amount,
-    uint256 marketId,
-    uint256 outcomeId
-  ) public view returns (uint256) {
-    Market storage market = markets[marketId];
-    require(outcomeId < market.outcomeCount, "!o");
-
-    uint256[] memory outcomesShares = getMarketOutcomesShares(marketId);
-    uint256 fee = getMarketSellFee(marketId);
-    uint256 amountPlusFees = (amount * ONE) / (ONE - fee);
-    uint256 sellTokenPoolBalance = outcomesShares[outcomeId];
-    uint256 endingOutcomeBalance = sellTokenPoolBalance * ONE;
-    for (uint256 i; i < market.outcomeCount; ++i) {
-      if (i != outcomeId) {
-        uint256 outcomeShares = outcomesShares[i];
-        endingOutcomeBalance = (endingOutcomeBalance * outcomeShares).ceildiv(outcomeShares - amountPlusFees);
-      }
-    }
-    require(endingOutcomeBalance > 0, "b0");
-
-    return amountPlusFees + endingOutcomeBalance.ceildiv(ONE) - sellTokenPoolBalance;
-  }
-
-  /// @dev Buy shares of a market outcome - returns gross amount of transaction (amount + fee)
-  function _buy(
-    uint256 marketId,
-    uint256 outcomeId,
-    uint256 minOutcomeSharesToBuy,
-    uint256 value
-  ) private timeTransitions(marketId) atState(marketId, MarketState.open) marketNotPaused(marketId) returns (uint256) {
-    Market storage market = markets[marketId];
-
-    uint256 shares = calcBuyAmount(value, marketId, outcomeId);
-    require(shares >= minOutcomeSharesToBuy, "s<m");
-    require(shares > 0, "s0");
-
-    // subtracting fee from transaction value
-    uint256 feeAmount = (value * market.fees.buyFees.fee) / ONE;
-    market.fees.poolWeight += feeAmount;
-    uint256 valueMinusFees = value - feeAmount;
-
-    uint256 treasuryFeeAmount = (value * market.fees.buyFees.treasuryFee) / ONE;
-    uint256 distributorFeeAmount = (value * market.fees.buyFees.distributorFee) / ONE;
-    valueMinusFees -= treasuryFeeAmount + distributorFeeAmount;
-
-    MarketOutcome storage outcome = market.outcomes[outcomeId];
-
-    // Funding market shares with received funds
-    _addSharesToMarket(marketId, valueMinusFees);
-
-    require(outcome.shares.available >= shares, "s<sp");
-
-    _transferOutcomeSharesfromPool(msg.sender, marketId, outcomeId, shares);
-
-    // value emmited in event includes fee (gross amount)
-    emit MarketActionTx(msg.sender, MarketAction.buy, marketId, outcomeId, shares, value, block.timestamp);
-    _emitMarketActionEvents(marketId);
-
-    // transfering treasury/distributor fees
-    if (treasuryFeeAmount > 0) {
-      market.token.safeTransfer(market.fees.treasury, treasuryFeeAmount);
-    }
-    if (distributorFeeAmount > 0) {
-      market.token.safeTransfer(market.fees.distributor, distributorFeeAmount);
-    }
-
-    return value;
-  }
-
-  /// @dev Buy shares of a market outcome
-  function buy(
-    uint256 marketId,
-    uint256 outcomeId,
-    uint256 minOutcomeSharesToBuy,
-    uint256 value
-  ) external nonReentrant {
-    Market storage market = markets[marketId];
-    market.token.safeTransferFrom(msg.sender, address(this), value);
-    _buy(marketId, outcomeId, minOutcomeSharesToBuy, value);
-  }
-
-  function buyWithETH(
-    uint256 marketId,
-    uint256 outcomeId,
-    uint256 minOutcomeSharesToBuy
-  ) external payable isWETHMarket(marketId) nonReentrant {
-    uint256 value = msg.value;
-    // wrapping and depositing funds
-    IWETH(WETH).deposit{value: value}();
-    _buy(marketId, outcomeId, minOutcomeSharesToBuy, value);
-  }
-
-  function referralBuy(
-    uint256 marketId,
-    uint256 outcomeId,
-    uint256 minOutcomeSharesToBuy,
-    uint256 value,
-    string memory code
-  ) public nonReentrant {
-    Market storage market = markets[marketId];
-    market.token.safeTransferFrom(msg.sender, address(this), value);
-    _buy(marketId, outcomeId, minOutcomeSharesToBuy, value);
-
-    emit Referral(msg.sender, marketId, code, MarketAction.buy, outcomeId, value, block.timestamp);
-  }
-
-  /// @dev Sell shares of a market outcome - returns gross amount of transaction (amount + fee)
-  function _sell(
-    uint256 marketId,
-    uint256 outcomeId,
-    uint256 value,
-    uint256 maxOutcomeSharesToSell
-  ) private timeTransitions(marketId) atState(marketId, MarketState.open) marketNotPaused(marketId) returns (uint256) {
-    Market storage market = markets[marketId];
-    MarketOutcome storage outcome = market.outcomes[outcomeId];
-
-    uint256 shares = calcSellAmount(value, marketId, outcomeId);
-
-    require(shares <= maxOutcomeSharesToSell, "s>m");
-    require(shares > 0, "s0");
-    require(outcome.shares.holders[msg.sender] >= shares, "s>h");
-
-    _transferOutcomeSharesToPool(msg.sender, marketId, outcomeId, shares);
-
-    // adding fees to transaction value
-    uint256 fee = getMarketSellFee(marketId);
-    uint256 oneMinusFee = ONE - fee;
-    {
-      uint256 feeAmount = (value * market.fees.sellFees.fee) / oneMinusFee;
-      market.fees.poolWeight += feeAmount;
-    }
-    uint256 valuePlusFees = value + (value * fee) / oneMinusFee;
-
-    require(market.balance >= valuePlusFees, "b<v");
-
-    // Rebalancing market shares
-    _removeSharesFromMarket(marketId, valuePlusFees);
-
-    // value emmited in event includes fee (gross amount)
-    emit MarketActionTx(msg.sender, MarketAction.sell, marketId, outcomeId, shares, valuePlusFees, block.timestamp);
-    _emitMarketActionEvents(marketId);
-
-    {
-      uint256 treasuryFeeAmount = (value * market.fees.sellFees.treasuryFee) / oneMinusFee;
-      uint256 distributorFeeAmount = (value * market.fees.sellFees.distributorFee) / oneMinusFee;
-      // transfering treasury/distributor fees
-      if (treasuryFeeAmount > 0) {
-        market.token.safeTransfer(market.fees.treasury, treasuryFeeAmount);
-      }
-      if (distributorFeeAmount > 0) {
-        market.token.safeTransfer(market.fees.distributor, distributorFeeAmount);
-      }
-    }
-
-    return valuePlusFees;
-  }
-
-  function sell(
-    uint256 marketId,
-    uint256 outcomeId,
-    uint256 value,
-    uint256 maxOutcomeSharesToSell
-  ) external nonReentrant {
-    _sell(marketId, outcomeId, value, maxOutcomeSharesToSell);
-    // Transferring funds to user
-    Market storage market = markets[marketId];
-    market.token.safeTransfer(msg.sender, value);
-  }
-
-  function sellToETH(
-    uint256 marketId,
-    uint256 outcomeId,
-    uint256 value,
-    uint256 maxOutcomeSharesToSell
-  ) external isWETHMarket(marketId) nonReentrant {
-    _sell(marketId, outcomeId, value, maxOutcomeSharesToSell);
-
-    IWETH(WETH).withdraw(value);
-    (bool sent, ) = payable(msg.sender).call{value: value}("");
-    require(sent, "!s");
-  }
-
-  function referralSell(
-    uint256 marketId,
-    uint256 outcomeId,
-    uint256 value,
-    uint256 maxOutcomeSharesToSell,
-    string memory code
-  ) external nonReentrant {
-    uint256 valuePlusFees = _sell(marketId, outcomeId, value, maxOutcomeSharesToSell);
-    // Transferring funds to user
-    Market storage market = markets[marketId];
-    market.token.safeTransfer(msg.sender, value);
-
-    emit Referral(msg.sender, marketId, code, MarketAction.sell, outcomeId, valuePlusFees, block.timestamp);
-  }
-
-  /// @dev Adds liquidity to a market - external
-  function _addLiquidity(
-    uint256 marketId,
-    uint256 value,
-    uint256[] memory distribution
-  ) private timeTransitions(marketId) atState(marketId, MarketState.open) marketNotPaused(marketId) {
-    Market storage market = markets[marketId];
-
-    require(value > 0, "v0");
-
-    uint256 liquidityAmount;
-
-    uint256[] memory outcomesShares = getMarketOutcomesShares(marketId);
-    uint256[] memory sendBackAmounts = new uint256[](market.outcomeCount);
-    uint256 poolWeight = 0;
-
-    if (market.liquidity > 0) {
-      require(distribution.length == 0, "!d");
-
-      // part of the liquidity is exchanged for outcome shares if market is not balanced
-      for (uint256 i; i < market.outcomeCount; ++i) {
-        uint256 outcomeShares = outcomesShares[i];
-        if (poolWeight < outcomeShares) poolWeight = outcomeShares;
-      }
-
-      for (uint256 i; i < market.outcomeCount; ++i) {
-        uint256 remaining = (value * outcomesShares[i]) / poolWeight;
-        sendBackAmounts[i] = value - remaining;
-      }
-
-      liquidityAmount = (value * market.liquidity) / poolWeight;
-
-      // re-balancing fees pool
-      _rebalanceFeesPool(marketId, liquidityAmount, MarketAction.addLiquidity);
-    } else {
-      uint256 distributionLength = distribution.length;
-      // funding market with no liquidity
-      if (distributionLength > 0) {
-        require(distributionLength == market.outcomeCount, "d!=oc");
-
-        uint256 maxHint = 0;
-        for (uint256 i; i < distributionLength; ++i) {
-          uint256 hint = distribution[i];
-          if (maxHint < hint) maxHint = hint;
-        }
-
-        for (uint256 i; i < distributionLength; ++i) {
-          uint256 remaining = (value * distribution[i]) / maxHint;
-          require(remaining > 0, "!d");
-          sendBackAmounts[i] = value - remaining;
-        }
-      }
-
-      // funding market with total liquidity amount
-      liquidityAmount = value;
-    }
-
-    // funding market
-    market.liquidity = market.liquidity + liquidityAmount;
-    market.liquidityShares[msg.sender] = market.liquidityShares[msg.sender] + liquidityAmount;
-
-    _addSharesToMarket(marketId, value);
-
-    {
-      // transform sendBackAmounts to array of amounts added
-      for (uint256 i; i < market.outcomeCount; ++i) {
-        if (sendBackAmounts[i] > 0) {
-          _transferOutcomeSharesfromPool(msg.sender, marketId, i, sendBackAmounts[i]);
-        }
-      }
-
-      // emitting events, using outcome 0 for price reference
-      uint256 referencePrice = getMarketOutcomePrice(marketId, 0);
-
-      for (uint256 i; i < market.outcomeCount; ++i) {
-        if (sendBackAmounts[i] > 0) {
-          // outcome price = outcome shares / reference outcome shares * reference outcome price
-          uint256 outcomePrice = (referencePrice * market.outcomes[0].shares.available) /
-            market.outcomes[i].shares.available;
-
-          emit MarketActionTx(
-            msg.sender,
-            MarketAction.buy,
-            marketId,
-            i,
-            sendBackAmounts[i],
-            (sendBackAmounts[i] * outcomePrice) / ONE, // price * shares
-            block.timestamp
-          );
-        }
-      }
-    }
-
-    uint256 liquidityPrice = getMarketLiquidityPrice(marketId);
-    uint256 liquidityValue = (liquidityPrice * liquidityAmount) / ONE;
-
-    emit MarketActionTx(
-      msg.sender,
-      MarketAction.addLiquidity,
-      marketId,
-      0,
-      liquidityAmount,
-      liquidityValue,
-      block.timestamp
-    );
-    emit MarketLiquidity(marketId, market.liquidity, liquidityPrice, block.timestamp);
-  }
-
-  function addLiquidity(uint256 marketId, uint256 value) external nonReentrant {
-    uint256[] memory distribution = new uint256[](0);
-    _addLiquidity(marketId, value, distribution);
-
-    Market storage market = markets[marketId];
-    market.token.safeTransferFrom(msg.sender, address(this), value);
-  }
-
-  /// @dev Removes liquidity to a market - external
-  function _removeLiquidity(uint256 marketId, uint256 shares)
-    private
-    timeTransitions(marketId)
-    atState(marketId, MarketState.open)
-    marketNotPaused(marketId)
-    returns (uint256)
-  {
-    Market storage market = markets[marketId];
-
-    // removing 100% of the liquidity is not allowed
-    require(shares < market.liquidity, "s>l");
-    require(market.liquidityShares[msg.sender] >= shares, "s>h");
-
-    // re-balancing fees pool
-    _rebalanceFeesPool(marketId, shares, MarketAction.removeLiquidity);
-
-    uint256[] memory outcomesShares = getMarketOutcomesShares(marketId);
-    uint256[] memory sendAmounts = new uint256[](market.outcomeCount);
-    uint256 poolWeight = MAX_UINT_256;
-
-    // part of the liquidity is exchanged for outcome shares if market is not balanced
-    for (uint256 i; i < market.outcomeCount; ++i) {
-      uint256 outcomeShares = outcomesShares[i];
-      if (poolWeight > outcomeShares) poolWeight = outcomeShares;
-    }
-
-    uint256 liquidityAmount = (shares * poolWeight) / market.liquidity;
-
-    for (uint256 i; i < market.outcomeCount; ++i) {
-      sendAmounts[i] = (outcomesShares[i] * shares) / market.liquidity;
-      sendAmounts[i] = sendAmounts[i] - liquidityAmount;
-    }
-
-    // removing liquidity from market
-    _removeSharesFromMarket(marketId, liquidityAmount);
-    market.liquidity = market.liquidity - shares;
-    // removing liquidity tokens from market creator
-    market.liquidityShares[msg.sender] = market.liquidityShares[msg.sender] - shares;
-
-    for (uint256 i; i < market.outcomeCount; ++i) {
-      if (sendAmounts[i] > 0) {
-        _transferOutcomeSharesfromPool(msg.sender, marketId, i, sendAmounts[i]);
-      }
-    }
-
-    // emitting events, using outcome 0 for price reference
-    uint256 referencePrice = getMarketOutcomePrice(marketId, 0);
-
-    for (uint256 i; i < market.outcomeCount; ++i) {
-      if (sendAmounts[i] > 0) {
-        // outcome price = outcome shares / reference outcome shares * reference outcome price
-        uint256 outcomePrice = (referencePrice * market.outcomes[0].shares.available) /
-          market.outcomes[i].shares.available;
-
-        emit MarketActionTx(
-          msg.sender,
-          MarketAction.buy,
-          marketId,
-          i,
-          sendAmounts[i],
-          (sendAmounts[i] * outcomePrice) / ONE, // price * shares
-          block.timestamp
-        );
-      }
-    }
-
-    emit MarketActionTx(
-      msg.sender,
-      MarketAction.removeLiquidity,
-      marketId,
-      0,
-      shares,
-      liquidityAmount,
-      block.timestamp
-    );
-    emit MarketLiquidity(marketId, market.liquidity, getMarketLiquidityPrice(marketId), block.timestamp);
-
-    return liquidityAmount;
-  }
-
-  function removeLiquidity(uint256 marketId, uint256 shares) external nonReentrant {
-    uint256 value = _removeLiquidity(marketId, shares);
-    // transferring user funds from liquidity removed
-    Market storage market = markets[marketId];
-    market.token.safeTransfer(msg.sender, value);
-  }
-
-  /// @dev Fetches winning outcome from Realitio and resolves the market
-  function resolveMarketOutcome(uint256 marketId)
-    external
-    timeTransitions(marketId)
-    atState(marketId, MarketState.closed)
-    transitionNext(marketId)
-    returns (uint256 outcomeId)
-  {
-    Market storage market = markets[marketId];
-
-    // will fail if question is not finalized
-    outcomeId = uint256(market.resolution.realitio.resultFor(market.resolution.questionId));
-
-    market.resolution.outcomeId = outcomeId;
-
-    emit MarketResolved(msg.sender, marketId, outcomeId, block.timestamp, false);
-    _emitMarketActionEvents(marketId);
-  }
-
-  /// @dev overrides market resolution, instead of using realitio
-  function adminResolveMarketOutcome(uint256 marketId, uint256 outcomeId)
-    external
-    notAtState(marketId, MarketState.resolved)
-    transitionLast(marketId)
-    returns (uint256)
-  {
-    Market storage market = markets[marketId];
-
-    require(market.manager.isAllowedToEditMarket(market.token, msg.sender), "not allowed to resolve market");
-
-    market.resolution.outcomeId = outcomeId;
-
-    emit MarketResolved(msg.sender, marketId, outcomeId, block.timestamp, true);
-    _emitMarketActionEvents(marketId);
-
-    return market.resolution.outcomeId;
-  }
-
-  /// @dev pauses a market, no trading allowed
-  function adminPauseMarket(uint256 marketId) external isMarket(marketId) marketNotPaused(marketId) nonReentrant {
-    Market storage market = markets[marketId];
-    require(market.manager.isAllowedToEditMarket(market.token, msg.sender), "not allowed to pause market");
-
-    market.paused = true;
-    emit MarketPaused(msg.sender, marketId, true, block.timestamp);
-  }
-
-  /// @dev unpauses a market, trading allowed
-  function adminUnpauseMarket(uint256 marketId) external isMarket(marketId) marketPaused(marketId) nonReentrant {
-    Market storage market = markets[marketId];
-    require(market.manager.isAllowedToEditMarket(market.token, msg.sender), "not allowed to unpause market");
-
-    market.paused = false;
-    emit MarketPaused(msg.sender, marketId, false, block.timestamp);
-  }
-
-  /// @dev overrides market close date
-  function adminSetMarketCloseDate(uint256 marketId, uint256 closesAt)
-    external
-    isMarket(marketId)
-    notAtState(marketId, MarketState.resolved)
-  {
-    Market storage market = markets[marketId];
-    require(market.manager.isAllowedToEditMarket(market.token, msg.sender), "not allowed to set close date");
-
-    require(closesAt > block.timestamp, "resolution before current date");
-    market.closesAtTimestamp = closesAt;
-    emit MarketCloseDateEdited(msg.sender, marketId, closesAt, block.timestamp);
-  }
-
-  /// @dev Allows holders of resolved outcome shares to claim earnings.
-  function _claimWinnings(uint256 marketId)
-    private
-    atState(marketId, MarketState.resolved)
-    marketNotPaused(marketId)
-    returns (uint256 value)
-  {
-    Market storage market = markets[marketId];
-    MarketOutcome storage resolvedOutcome = market.outcomes[market.resolution.outcomeId];
-
-    require(!isMarketVoided(marketId), "mv");
-    require(resolvedOutcome.shares.holders[msg.sender] > 0, "!h");
-    require(!resolvedOutcome.shares.claims[msg.sender], "!c");
-
-    // 1 share => price = 1
-    value = resolvedOutcome.shares.holders[msg.sender];
-
-    // assuring market has enough funds
-    require(market.balance >= value, "b<v");
-
-    market.balance = market.balance - value;
-    resolvedOutcome.shares.claims[msg.sender] = true;
-
-    emit MarketActionTx(
-      msg.sender,
-      MarketAction.claimWinnings,
-      marketId,
-      market.resolution.outcomeId,
-      resolvedOutcome.shares.holders[msg.sender],
-      value,
-      block.timestamp
-    );
-  }
-
-  function claimWinnings(uint256 marketId) external nonReentrant {
-    uint256 value = _claimWinnings(marketId);
-    // transferring user funds from winnings claimed
-    Market storage market = markets[marketId];
-    market.token.safeTransfer(msg.sender, value);
-  }
-
-  /// @dev Allows holders of voided outcome shares to claim balance back.
-  function _claimVoidedOutcomeShares(uint256 marketId, uint256 outcomeId)
-    private
-    atState(marketId, MarketState.resolved)
-    marketNotPaused(marketId)
-    returns (uint256 value)
-  {
-    Market storage market = markets[marketId];
-    MarketOutcome storage outcome = market.outcomes[outcomeId];
-
-    require(isMarketVoided(marketId), "!mv");
-    require(outcome.shares.holders[msg.sender] > 0, "!h");
-    require(!outcome.shares.voidedClaims[msg.sender], "!c");
-
-    // voided market - shares are valued at last market price
-    uint256 price = getMarketOutcomePrice(marketId, outcomeId);
-    value = (price * outcome.shares.holders[msg.sender]) / ONE;
-
-    // assuring market has enough funds
-    require(market.balance >= value, "b<v");
-
-    market.balance = market.balance - value;
-    outcome.shares.voidedClaims[msg.sender] = true;
-
-    emit MarketActionTx(
-      msg.sender,
-      MarketAction.claimVoided,
-      marketId,
-      outcomeId,
-      outcome.shares.holders[msg.sender],
-      value,
-      block.timestamp
-    );
-
-    return value;
-  }
-
-  function claimVoidedOutcomeShares(uint256 marketId, uint256 outcomeId) external nonReentrant {
-    uint256 value = _claimVoidedOutcomeShares(marketId, outcomeId);
-    // transferring user funds from voided outcome shares claimed
-    Market storage market = markets[marketId];
-    market.token.safeTransfer(msg.sender, value);
-  }
-
-  /// @dev Allows liquidity providers to claim earnings from liquidity providing.
-  function _claimLiquidity(uint256 marketId)
-    private
-    atState(marketId, MarketState.resolved)
-    marketNotPaused(marketId)
-    returns (uint256 value)
-  {
-    Market storage market = markets[marketId];
-
-    require(market.liquidityShares[msg.sender] > 0, "!h");
-    require(!market.liquidityClaims[msg.sender], "!c");
-
-    // value = total resolved outcome pool shares * pool share (%)
-    uint256 liquidityPrice = getMarketLiquidityPrice(marketId);
-    value = (liquidityPrice * market.liquidityShares[msg.sender]) / ONE;
-
-    // assuring market has enough funds
-    require(market.balance >= value, "b<v");
-
-    market.balance = market.balance - value;
-    market.liquidityClaims[msg.sender] = true;
-
-    emit MarketActionTx(
-      msg.sender,
-      MarketAction.claimLiquidity,
-      marketId,
-      0,
-      market.liquidityShares[msg.sender],
-      value,
-      block.timestamp
-    );
-  }
-
-  function claimLiquidity(uint256 marketId) external nonReentrant {
-    uint256 value = _claimLiquidity(marketId);
-    // transferring user funds from liquidity claimed
-    Market storage market = markets[marketId];
-    market.token.safeTransfer(msg.sender, value);
-
-    // claiming any pending fees
-    uint256 feesValue = _claimFees(marketId);
-    if (feesValue > 0) {
-      market.token.safeTransfer(msg.sender, feesValue);
-    }
-  }
-
-  /// @dev Allows liquidity providers to claim their fees share from fees pool
-  function _claimFees(uint256 marketId) private marketNotPaused(marketId) returns (uint256 value) {
-    Market storage market = markets[marketId];
-
-    value = getUserClaimableFees(marketId, msg.sender);
-
-    if (value > 0) {
-      market.fees.claimed[msg.sender] = market.fees.claimed[msg.sender] + value;
-    }
-
-    emit MarketActionTx(
-      msg.sender,
-      MarketAction.claimFees,
-      marketId,
-      0,
-      market.liquidityShares[msg.sender],
-      value,
-      block.timestamp
-    );
-  }
-
-  function claimFees(uint256 marketId) public nonReentrant {
-    uint256 value = _claimFees(marketId);
-    // transferring user funds from fees claimed
-    Market storage market = markets[marketId];
-    market.token.safeTransfer(msg.sender, value);
-  }
-
-  /// @dev Rebalances the fees pool. Needed in every AddLiquidity / RemoveLiquidity call
-  function _rebalanceFeesPool(
-    uint256 marketId,
-    uint256 liquidityShares,
-    MarketAction action
-  ) private {
-    Market storage market = markets[marketId];
-
-    uint256 poolWeight = (liquidityShares * market.fees.poolWeight) / market.liquidity;
-
-    if (action == MarketAction.addLiquidity) {
-      market.fees.poolWeight += poolWeight;
-      market.fees.claimed[msg.sender] += poolWeight;
-    } else {
-      market.fees.poolWeight -= poolWeight;
-      market.fees.claimed[msg.sender] = market.fees.claimed[msg.sender] - poolWeight;
-    }
-  }
-
-  /// @dev Transitions market to next state
-  function _nextState(uint256 marketId) private {
-    Market storage market = markets[marketId];
-    market.state = MarketState(uint256(market.state) + 1);
-  }
-
-  /// @dev Transitions market to last state
-  function _lastState(uint256 marketId) private {
-    Market storage market = markets[marketId];
-    market.state = MarketState.resolved;
-  }
-
-  /// @dev Emits a outcome price event for every outcome
-  function _emitMarketActionEvents(uint256 marketId) private {
-    Market storage market = markets[marketId];
-    uint256[] memory outcomeShares = new uint256[](market.outcomeCount);
-
-    for (uint256 i; i < market.outcomeCount; ++i) {
-      outcomeShares[i] = market.outcomes[i].shares.available;
-    }
-
-    emit MarketOutcomeShares(marketId, block.timestamp, outcomeShares, market.liquidity);
-  }
-
-  /// @dev Adds outcome shares to shares pool
-  function _addSharesToMarket(uint256 marketId, uint256 shares) private {
-    Market storage market = markets[marketId];
-
-    for (uint256 i; i < market.outcomeCount; ++i) {
-      MarketOutcome storage outcome = market.outcomes[i];
-
-      outcome.shares.available = outcome.shares.available + shares;
-      outcome.shares.total = outcome.shares.total + shares;
-
-      // only adding to market total shares, the available remains
-      market.sharesAvailable = market.sharesAvailable + shares;
-    }
-
-    market.balance = market.balance + shares;
-  }
-
-  /// @dev Removes outcome shares from shares pool
-  function _removeSharesFromMarket(uint256 marketId, uint256 shares) private {
-    Market storage market = markets[marketId];
-
-    for (uint256 i; i < market.outcomeCount; ++i) {
-      MarketOutcome storage outcome = market.outcomes[i];
-
-      outcome.shares.available = outcome.shares.available - shares;
-      outcome.shares.total = outcome.shares.total - shares;
-
-      // only subtracting from market total shares, the available remains
-      market.sharesAvailable = market.sharesAvailable - shares;
-    }
-
-    market.balance = market.balance - shares;
-  }
-
-  /// @dev Transfer outcome shares from pool to user balance
-  function _transferOutcomeSharesfromPool(
-    address user,
-    uint256 marketId,
-    uint256 outcomeId,
-    uint256 shares
-  ) private {
-    Market storage market = markets[marketId];
-    MarketOutcome storage outcome = market.outcomes[outcomeId];
-
-    // transfering shares from shares pool to user
-    outcome.shares.holders[user] = outcome.shares.holders[user] + shares;
-    outcome.shares.available = outcome.shares.available - shares;
-    market.sharesAvailable = market.sharesAvailable - shares;
-  }
-
-  /// @dev Transfer outcome shares from user balance back to pool
-  function _transferOutcomeSharesToPool(
-    address user,
-    uint256 marketId,
-    uint256 outcomeId,
-    uint256 shares
-  ) private {
-    Market storage market = markets[marketId];
-    MarketOutcome storage outcome = market.outcomes[outcomeId];
-
-    // adding shares back to pool
-    outcome.shares.holders[user] = outcome.shares.holders[user] - shares;
-    outcome.shares.available = outcome.shares.available + shares;
-    market.sharesAvailable = market.sharesAvailable + shares;
-  }
-
-  // ------ Core Functions End ------
-
-  // ------ Getters ------
-
-  function getUserMarketShares(uint256 marketId, address user)
-    external
-    view
-    returns (uint256 liquidity, uint256[] memory outcomes)
-  {
-    Market storage market = markets[marketId];
-    uint256[] memory outcomeShares = new uint256[](market.outcomeCount);
-
-    for (uint256 i; i < market.outcomeCount; ++i) {
-      outcomeShares[i] = market.outcomes[i].shares.holders[user];
-    }
-
-    return (market.liquidityShares[user], outcomeShares);
-  }
-
-  function getUserClaimStatus(uint256 marketId, address user)
-    external
-    view
-    returns (
-      bool winningsToClaim,
-      bool winningsClaimed,
-      bool liquidityToClaim,
-      bool liquidityClaimed,
-      uint256 claimableFees
-    )
-  {
-    Market storage market = markets[marketId];
-
-    // market still not resolved
-    if (market.state != MarketState.resolved) {
-      return (false, false, false, false, getUserClaimableFees(marketId, user));
-    }
-
-    MarketOutcome storage outcome = market.outcomes[market.resolution.outcomeId];
-
-    return (
-      outcome.shares.holders[user] > 0,
-      outcome.shares.claims[user],
-      market.liquidityShares[user] > 0,
-      market.liquidityClaims[user],
-      getUserClaimableFees(marketId, user)
-    );
-  }
-
-  function getUserLiquidityPoolShare(uint256 marketId, address user) external view returns (uint256) {
-    Market storage market = markets[marketId];
-
-    return (market.liquidityShares[user] * ONE) / market.liquidity;
-  }
-
-  function getUserClaimableFees(uint256 marketId, address user) public view returns (uint256) {
-    Market storage market = markets[marketId];
-
-    uint256 rawAmount = (market.fees.poolWeight * market.liquidityShares[user]) / market.liquidity;
-
-    // No fees left to claim
-    if (market.fees.claimed[user] > rawAmount) return 0;
-
-    return rawAmount - market.fees.claimed[user];
-  }
-
-  function getMarkets() external view returns (uint256[] memory) {
-    return marketIds;
-  }
-
-  function getMarketData(uint256 marketId)
-    external
-    view
-    returns (
-      MarketState state,
-      uint256 closesAt,
-      uint256 liquidity,
-      uint256 balance,
-      uint256 sharesAvailable,
-      int256 resolvedOutcomeId
-    )
-  {
-    Market storage market = markets[marketId];
-
-    return (
-      market.state,
-      market.closesAtTimestamp,
-      market.liquidity,
-      market.balance,
-      market.sharesAvailable,
-      getMarketResolvedOutcome(marketId)
-    );
-  }
-
-  function getMarketAltData(uint256 marketId)
-    external
-    view
-    returns (
-      uint256 buyFee,
-      bytes32 questionId,
-      uint256 questionIdUint,
-      IERC20 token,
-      uint256 buyTreasuryFee,
-      address treasury,
-      IRealityETH_ERC20 realitio,
-      uint256 realitioTimeout,
-      IPredictionMarketV3Manager manager
-    )
-  {
-    Market storage market = markets[marketId];
-
-    return (
-      market.fees.buyFees.fee,
-      market.resolution.questionId,
-      uint256(market.resolution.questionId),
-      market.token,
-      market.fees.buyFees.treasuryFee,
-      market.fees.treasury,
-      market.resolution.realitio,
-      market.resolution.realitioTimeout,
-      market.manager
-    );
-  }
-
-  function getMarketCreator(uint256 marketId) external view returns (address) {
-    Market storage market = markets[marketId];
-
-    return market.creator;
-  }
-
-  function getMarketQuestion(uint256 marketId) external view returns (bytes32) {
-    Market storage market = markets[marketId];
-
-    return (market.resolution.questionId);
-  }
-
-  function getMarketPrices(uint256 marketId) external view returns (uint256 liquidity, uint256[] memory outcomes) {
-    Market storage market = markets[marketId];
-    uint256[] memory prices = new uint256[](market.outcomeCount);
-
-    for (uint256 i; i < market.outcomeCount; ++i) {
-      prices[i] = getMarketOutcomePrice(marketId, i);
-    }
-
-    return (getMarketLiquidityPrice(marketId), prices);
-  }
-
-  function getMarketShares(uint256 marketId) external view returns (uint256 liquidity, uint256[] memory outcomes) {
-    Market storage market = markets[marketId];
-    uint256[] memory outcomeShares = new uint256[](market.outcomeCount);
-
-    for (uint256 i; i < market.outcomeCount; ++i) {
-      outcomeShares[i] = market.outcomes[i].shares.available;
-    }
-
-    return (market.liquidity, outcomeShares);
-  }
-
-  function getMarketLiquidityPrice(uint256 marketId) public view returns (uint256) {
-    Market storage market = markets[marketId];
-
-    if (market.state == MarketState.resolved && !isMarketVoided(marketId)) {
-      // resolved market, outcome prices are either 0 or 1
-      // final liquidity price = outcome shares / liquidity shares
-      return (market.outcomes[market.resolution.outcomeId].shares.available * ONE) / market.liquidity;
-    }
-
-    // liquidity price = # outcomes / (liquidity * sum (1 / every outcome shares)
-    uint256 marketSharesSum = 0;
-
-    for (uint256 i; i < market.outcomeCount; ++i) {
-      MarketOutcome storage outcome = market.outcomes[i];
-
-      marketSharesSum = marketSharesSum + (ONE * ONE) / outcome.shares.available;
-    }
-
-    return (market.outcomeCount * ONE * ONE * ONE) / market.liquidity / marketSharesSum;
-  }
-
-  function getMarketResolvedOutcome(uint256 marketId) public view returns (int256) {
-    Market storage market = markets[marketId];
-
-    // returning -1 if market still not resolved
-    if (market.state != MarketState.resolved) {
-      return -1;
-    }
-
-    return int256(market.resolution.outcomeId);
-  }
-
-  function isMarketVoided(uint256 marketId) public view returns (bool) {
-    Market storage market = markets[marketId];
-
-    // market still not resolved, still in valid state
-    if (market.state != MarketState.resolved) {
-      return false;
-    }
-
-    // resolved market id does not match any of the market ids
-    return market.resolution.outcomeId >= market.outcomeCount;
-  }
-
-  function getMarketBuyFee(uint256 marketId) public view returns (uint256) {
-    Market storage market = markets[marketId];
-
-    return market.fees.buyFees.fee + market.fees.buyFees.treasuryFee + market.fees.buyFees.distributorFee;
-  }
-
-  function getMarketSellFee(uint256 marketId) public view returns (uint256) {
-    Market storage market = markets[marketId];
-
-    return market.fees.sellFees.fee + market.fees.sellFees.treasuryFee + market.fees.sellFees.distributorFee;
-  }
-
-  // alias of getMarketBuyFee, used for compatibility
-  function getMarketFee(uint256 marketId) public view returns (uint256) {
-    return getMarketBuyFee(marketId);
-  }
-
-  function getMarketFees(uint256 marketId)
-    external
-    view
-    returns (
-      Fees memory buyFees,
-      Fees memory sellFees,
-      address treasury,
-      address distributor
-    )
-  {
-    Market storage market = markets[marketId];
-
-    return (market.fees.buyFees, market.fees.sellFees, market.fees.treasury, market.fees.distributor);
-  }
-
-  // ------ Outcome Getters ------
-
-  function getMarketOutcomeIds(uint256 marketId) external view returns (uint256[] memory outcomeIds) {
-    Market storage market = markets[marketId];
-    outcomeIds = new uint256[](market.outcomeCount);
-
-    for (uint256 i; i < market.outcomeCount; ++i) {
-      outcomeIds[i] = i;
-    }
-  }
-
-  function getMarketOutcomePrice(uint256 marketId, uint256 outcomeId) public view returns (uint256) {
-    Market storage market = markets[marketId];
-
-    if (market.state == MarketState.resolved && !isMarketVoided(marketId)) {
-      // resolved market, price is either 0 or 1
-      return outcomeId == market.resolution.outcomeId ? ONE : 0;
-    }
-
-    // outcome price = 1 / (1 + sum(outcome shares / every outcome shares))
-    uint256 div = ONE;
-    for (uint256 i; i < market.outcomeCount; ++i) {
-      if (i == outcomeId) continue;
-
-      div = div + (market.outcomes[outcomeId].shares.available * ONE) / market.outcomes[i].shares.available;
-    }
-
-    return (ONE * ONE) / div;
-  }
-
-  function getMarketOutcomeData(uint256 marketId, uint256 outcomeId)
-    external
-    view
-    returns (
-      uint256 price,
-      uint256 availableShares,
-      uint256 totalShares
-    )
-  {
-    Market storage market = markets[marketId];
-    MarketOutcome storage outcome = market.outcomes[outcomeId];
-
-    return (getMarketOutcomePrice(marketId, outcomeId), outcome.shares.available, outcome.shares.total);
-  }
-
-  function getMarketOutcomesShares(uint256 marketId) public view returns (uint256[] memory shares) {
-    Market storage market = markets[marketId];
-
-    shares = new uint256[](market.outcomeCount);
-    for (uint256 i; i < market.outcomeCount; ++i) {
-      shares[i] = market.outcomes[i].shares.available;
-    }
-  }
-
-  function getMarketPaused(uint256 marketId) external view returns (bool) {
-    Market storage market = markets[marketId];
-
-    return market.paused;
-  }
-
-  // ------ Ownable Setters ------
-
-  function setAllowedManager(address manager, bool allowed) external onlyOwner {
-    allowedManagers[manager] = allowed;
-    emit AllowedManagerSet(manager, allowed);
-  }
-
-  function withdraw(address token, uint256 amount) external onlyOwner {
-    IERC20(token).safeTransfer(msg.sender, amount);
-  }
-
-  function pause() external onlyOwner whenNotPaused {
-    paused = true;
-    emit Paused(true, msg.sender);
-  }
-
-  function unpause() external onlyOwner whenPaused {
-    paused = false;
-    emit Paused(false, msg.sender);
-  }
-
-  function setTestVarInTheBeginning(uint256 _testVarInTheBeginning) external {
-    testVarInTheBeginning = _testVarInTheBeginning;
-  }
-
-  function setTestVarInTheBeginningArray(uint256[] memory _testVarInTheBeginningArray) external {
-    testVarInTheBeginningArray = _testVarInTheBeginningArray;
-  }
-
-  // ------ Upgrade Authorization ------
-
-  /// @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract
-  function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
-}