prediction-market-agent-tooling 0.64.12.dev659__py3-none-any.whl → 0.65.0__py3-none-any.whl

prediction_market_agent_tooling/markets/omen/omen.py

@@ -1,7 +1,9 @@
 import typing as t
+from collections import defaultdict
 from datetime import timedelta
 
 import tenacity
+from tqdm import tqdm
 from web3 import Web3
 
 from prediction_market_agent_tooling.config import APIKeys
@@ -43,8 +45,6 @@ from prediction_market_agent_tooling.markets.omen.data_models import (
     OmenBet,
     OmenMarket,
     OmenUserPosition,
-    get_bet_outcome,
-    get_boolean_outcome,
 )
 from prediction_market_agent_tooling.markets.omen.omen_contracts import (
     OMEN_DEFAULT_MARKET_FEE_PERC,
@@ -59,7 +59,6 @@ from prediction_market_agent_tooling.markets.omen.omen_contracts import (
     build_parent_collection_id,
 )
 from prediction_market_agent_tooling.markets.omen.omen_subgraph_handler import (
-    SAFE_COLLATERAL_TOKENS_ADDRESSES,
     OmenSubgraphHandler,
 )
 from prediction_market_agent_tooling.tools.balances import get_balances
@@ -160,14 +159,14 @@ class OmenAgentMarket(AgentMarket):
 
     def liquidate_existing_positions(
         self,
-        bet_outcome: bool,
+        bet_outcome: OutcomeStr,
         web3: Web3 | None = None,
         api_keys: APIKeys | None = None,
         larger_than: OutcomeToken | None = None,
     ) -> None:
         """
         Liquidates all previously existing positions.
-        Returns the amount in collateral obtained by selling the positions.
+
         """
         api_keys = api_keys if api_keys is not None else APIKeys()
         better_address = api_keys.bet_from_address
@@ -180,10 +179,9 @@ class OmenAgentMarket(AgentMarket):
 
         for prev_position in prev_positions_for_market:
             for position_outcome, token_amount in prev_position.amounts_ot.items():
-                position_outcome_bool = get_boolean_outcome(position_outcome)
-                if position_outcome_bool != bet_outcome:
+                if position_outcome != bet_outcome:
                     self.sell_tokens(
-                        outcome=position_outcome_bool,
+                        outcome=position_outcome,
                         amount=token_amount,
                         auto_withdraw=True,
                         web3=web3,
@@ -192,7 +190,7 @@ class OmenAgentMarket(AgentMarket):
 
     def place_bet(
         self,
-        outcome: bool,
+        outcome: OutcomeStr,
         amount: USD,
         auto_deposit: bool = True,
         web3: Web3 | None = None,
@@ -206,14 +204,14 @@ class OmenAgentMarket(AgentMarket):
             api_keys=api_keys if api_keys is not None else APIKeys(),
             amount=amount,
             market=self,
-            binary_outcome=outcome,
+            outcome=outcome,
             auto_deposit=auto_deposit,
             web3=web3,
         )
 
     def buy_tokens(
         self,
-        outcome: bool,
+        outcome: OutcomeStr,
         amount: USD,
         web3: Web3 | None = None,
         api_keys: APIKeys | None = None,
@@ -226,7 +224,7 @@ class OmenAgentMarket(AgentMarket):
         )
 
     def get_sell_value_of_outcome_token(
-        self, outcome: str, amount: OutcomeToken, web3: Web3 | None = None
+        self, outcome: OutcomeStr, amount: OutcomeToken, web3: Web3 | None = None
     ) -> CollateralToken:
         """
         Market can have as collateral token GNO for example.
@@ -234,19 +232,15 @@ class OmenAgentMarket(AgentMarket):
         When selling, you need to provide the amount in GNO, which is cumbersome because you know how much shares you have, but you don't have the price of the shares in GNO.
         Use this to convert how much collateral token (GNO in our example) to sell, to get the amount of shares you want to sell.
         """
-        outcome_bool = get_boolean_outcome(outcome)
 
         pool_balance = get_conditional_tokens_balance_for_market(
             self, self.market_maker_contract_address_checksummed, web3=web3
         )
-
-        sell_str = self.outcomes[self.yes_index if outcome_bool else self.no_index]
-        other_str = self.outcomes[self.no_index if outcome_bool else self.yes_index]
-
+        outcome_idx = self.index_set_to_outcome_index(self.get_index_set(outcome))
         collateral = calculate_sell_amount_in_collateral(
             shares_to_sell=amount,
-            holdings=pool_balance[self.get_index_set(sell_str)].as_outcome_token,
-            other_holdings=pool_balance[self.get_index_set(other_str)].as_outcome_token,
+            outcome_index=outcome_idx,
+            pool_balances=[x.as_outcome_token for x in pool_balance.values()],
             fees=self.fees,
         )
 
@@ -254,7 +248,7 @@ class OmenAgentMarket(AgentMarket):
 
     def sell_tokens(
         self,
-        outcome: bool,
+        outcome: OutcomeStr,
         amount: USD | OutcomeToken,
         auto_withdraw: bool = True,
         api_keys: APIKeys | None = None,
@@ -268,7 +262,7 @@ class OmenAgentMarket(AgentMarket):
             amount=amount,
             api_keys=api_keys if api_keys is not None else APIKeys(),
             market=self,
-            binary_outcome=outcome,
+            outcome=outcome,
             auto_withdraw=auto_withdraw,
             web3=web3,
         )
@@ -347,7 +341,6 @@ class OmenAgentMarket(AgentMarket):
             resolution=model.get_resolution_enum(),
             created_time=model.creation_datetime,
             finalized_time=model.finalized_datetime,
-            current_p_yes=model.current_p_yes,
             condition=model.condition,
             url=model.url,
             volume=model.collateralVolume.as_token,
@@ -362,24 +355,30 @@ class OmenAgentMarket(AgentMarket):
                 model.outcomes[i]: model.outcomeTokenAmounts[i].as_outcome_token
                 for i in range(len(model.outcomes))
             },
+            probabilities=AgentMarket.build_probability_map(
+                outcome_token_amounts=model.outcomeTokenAmounts,
+                outcomes=list(model.outcomes),
+            ),
         )
 
     @staticmethod
-    def get_binary_markets(
+    def get_markets(
         limit: int,
         sort_by: SortBy,
         filter_by: FilterBy = FilterBy.OPEN,
         created_after: t.Optional[DatetimeUTC] = None,
         excluded_questions: set[str] | None = None,
+        fetch_categorical_markets: bool = False,
     ) -> t.Sequence["OmenAgentMarket"]:
         return [
             OmenAgentMarket.from_data_model(m)
-            for m in OmenSubgraphHandler().get_omen_binary_markets_simple(
+            for m in OmenSubgraphHandler().get_omen_markets_simple(
                 limit=limit,
                 sort_by=sort_by,
                 filter_by=filter_by,
                 created_after=created_after,
                 excluded_questions=excluded_questions,
+                include_categorical_markets=fetch_categorical_markets,
             )
         ]
 
@@ -471,7 +470,7 @@ class OmenAgentMarket(AgentMarket):
             address=self.market_maker_contract_address_checksummed,
         )
 
-    def get_index_set(self, outcome: str) -> int:
+    def get_index_set(self, outcome: OutcomeStr) -> int:
         return self.get_outcome_index(outcome) + 1
 
     def index_set_to_outcome_index(cls, index_set: int) -> int:
@@ -482,13 +481,14 @@ class OmenAgentMarket(AgentMarket):
             cls.get_outcome_str(cls.index_set_to_outcome_index(index_set))
         )
 
-    def get_outcome_str_from_bool(self, outcome: bool) -> OutcomeStr:
+    @staticmethod
+    def get_outcome_str_from_bool(outcome: bool) -> OutcomeStr:
         return (
             OutcomeStr(OMEN_TRUE_OUTCOME) if outcome else OutcomeStr(OMEN_FALSE_OUTCOME)
         )
 
     def get_token_balance(
-        self, user_id: str, outcome: str, web3: Web3 | None = None
+        self, user_id: str, outcome: OutcomeStr, web3: Web3 | None = None
     ) -> OutcomeToken:
         index_set = self.get_index_set(outcome)
         balances = get_conditional_tokens_balance_for_market(
@@ -522,16 +522,20 @@ class OmenAgentMarket(AgentMarket):
         )
 
         # Sort positions and corresponding markets by condition_id
-        omen_positions_dict: dict[HexBytes, list[OmenUserPosition]] = {}
+        omen_positions_dict: dict[HexBytes, list[OmenUserPosition]] = defaultdict(list)
+
         for omen_position in omen_positions:
-            condition_id = omen_position.position.condition_id
-            omen_positions_dict.setdefault(condition_id, []).append(omen_position)
+            omen_positions_dict[omen_position.position.condition_id].append(
+                omen_position
+            )
 
+        # We include categorical markets below simply because we are already filtering on condition_ids.
         omen_markets: dict[HexBytes, OmenMarket] = {
             m.condition.id: m
-            for m in sgh.get_omen_binary_markets(
+            for m in sgh.get_omen_markets(
                 limit=None,
                 condition_id_in=list(omen_positions_dict.keys()),
+                include_categorical_markets=True,
             )
         }
 
@@ -545,7 +549,9 @@ class OmenAgentMarket(AgentMarket):
             )
 
         positions = []
-        for condition_id, omen_positions in omen_positions_dict.items():
+        for condition_id, omen_positions in tqdm(
+            omen_positions_dict.items(), mininterval=3
+        ):
             market = cls.from_data_model(omen_markets[condition_id])
 
             # Skip markets that cannot be traded if `liquid_only`` is True.
@@ -595,7 +601,7 @@ class OmenAgentMarket(AgentMarket):
         return get_omen_user_url(keys.bet_from_address)
 
     def get_buy_token_amount(
-        self, bet_amount: USD | CollateralToken, direction: bool
+        self, bet_amount: USD | CollateralToken, outcome: OutcomeStr
     ) -> OutcomeToken:
         """
         Note: this is only valid if the market instance's token pool is
@@ -604,63 +610,26 @@ class OmenAgentMarket(AgentMarket):
         outcome_token_pool = check_not_none(self.outcome_token_pool)
         amount = get_buy_outcome_token_amount(
             investment_amount=self.get_in_token(bet_amount),
-            buy_direction=direction,
-            yes_outcome_pool_size=outcome_token_pool[OMEN_TRUE_OUTCOME],
-            no_outcome_pool_size=outcome_token_pool[OMEN_FALSE_OUTCOME],
+            outcome_index=self.get_outcome_index(outcome),
+            pool_balances=[outcome_token_pool[x] for x in self.outcomes],
             fees=self.fees,
         )
         return amount
 
     def _get_buy_token_amount_from_smart_contract(
-        self, bet_amount: USD, direction: bool
+        self, bet_amount: USD, outcome: OutcomeStr
     ) -> OutcomeToken:
         bet_amount_in_tokens = get_usd_in_token(
             bet_amount, self.collateral_token_contract_address_checksummed
         )
+
         received_token_amount_wei = self.get_contract().calcBuyAmount(
             investment_amount=bet_amount_in_tokens.as_wei,
-            outcome_index=self.get_outcome_index(
-                self.get_outcome_str_from_bool(direction)
-            ),
+            outcome_index=self.get_outcome_index(outcome),
         )
         received_token_amount = received_token_amount_wei.as_outcome_token
         return received_token_amount
 
-    def get_new_p_yes(self, bet_amount: USD, direction: bool) -> Probability:
-        """
-        Calculate the new p_yes based on the bet amount and direction.
-        """
-        if not self.has_token_pool():
-            raise ValueError("Outcome token pool is required to calculate new p_yes.")
-
-        bet_amount_in_tokens = self.get_usd_in_token(bet_amount)
-        outcome_token_pool = check_not_none(self.outcome_token_pool)
-
-        yes_outcome_pool_size = outcome_token_pool[
-            self.get_outcome_str_from_bool(True)
-        ].value
-        no_outcome_pool_size = outcome_token_pool[
-            self.get_outcome_str_from_bool(False)
-        ].value
-
-        new_yes_outcome_pool_size = yes_outcome_pool_size + (
-            self.fees.get_after_fees(bet_amount_in_tokens).value
-        )
-        new_no_outcome_pool_size = no_outcome_pool_size + (
-            self.fees.get_after_fees(bet_amount_in_tokens).value
-        )
-
-        received_token_amount = self.get_buy_token_amount(bet_amount, direction).value
-        if direction:
-            new_yes_outcome_pool_size -= received_token_amount
-        else:
-            new_no_outcome_pool_size -= received_token_amount
-
-        new_p_yes = new_no_outcome_pool_size / (
-            new_yes_outcome_pool_size + new_no_outcome_pool_size
-        )
-        return Probability(new_p_yes)
-
     @staticmethod
     def get_user_balance(user_id: str) -> float:
         return float(get_balances(Web3.to_checksum_address(user_id)).total)
@@ -688,22 +657,6 @@ def get_omen_user_url(address: ChecksumAddress) -> str:
     return f"https://gnosisscan.io/address/{address}"
 
 
-def pick_binary_market(
-    sort_by: SortBy = SortBy.CLOSING_SOONEST,
-    filter_by: FilterBy = FilterBy.OPEN,
-    collateral_token_address_in: (
-        tuple[ChecksumAddress, ...] | None
-    ) = SAFE_COLLATERAL_TOKENS_ADDRESSES,
-) -> OmenMarket:
-    subgraph_handler = OmenSubgraphHandler()
-    return subgraph_handler.get_omen_binary_markets_simple(
-        limit=1,
-        sort_by=sort_by,
-        filter_by=filter_by,
-        collateral_token_address_in=collateral_token_address_in,
-    )[0]
-
-
 @tenacity.retry(
     stop=tenacity.stop_after_attempt(3),
     wait=tenacity.wait_fixed(1),
@@ -713,7 +666,7 @@ def omen_buy_outcome_tx(
     api_keys: APIKeys,
     amount: USD | CollateralToken,
     market: OmenAgentMarket,
-    outcome: str,
+    outcome: OutcomeStr,
     auto_deposit: bool,
     web3: Web3 | None = None,
     slippage: float = 0.01,
@@ -769,7 +722,7 @@ def binary_omen_buy_outcome_tx(
     api_keys: APIKeys,
     amount: USD | CollateralToken,
     market: OmenAgentMarket,
-    binary_outcome: bool,
+    outcome: OutcomeStr,
     auto_deposit: bool,
     web3: Web3 | None = None,
 ) -> str:
@@ -777,7 +730,7 @@ def binary_omen_buy_outcome_tx(
         api_keys=api_keys,
         amount=amount,
         market=market,
-        outcome=get_bet_outcome(binary_outcome),
+        outcome=outcome,
         auto_deposit=auto_deposit,
         web3=web3,
     )
@@ -787,7 +740,7 @@ def omen_sell_outcome_tx(
     api_keys: APIKeys,
     amount: OutcomeToken | CollateralToken | USD,
     market: OmenAgentMarket,
-    outcome: str,
+    outcome: OutcomeStr,
     auto_withdraw: bool,
     web3: Web3 | None = None,
     slippage: float = 0.01,
@@ -863,7 +816,7 @@ def binary_omen_sell_outcome_tx(
     api_keys: APIKeys,
     amount: OutcomeToken | CollateralToken | USD,
     market: OmenAgentMarket,
-    binary_outcome: bool,
+    outcome: OutcomeStr,
     auto_withdraw: bool,
     web3: Web3 | None = None,
 ) -> str:
@@ -871,7 +824,7 @@ def binary_omen_sell_outcome_tx(
         api_keys=api_keys,
         amount=amount,
         market=market,
-        outcome=get_bet_outcome(binary_outcome),
+        outcome=outcome,
         auto_withdraw=auto_withdraw,
         web3=web3,
     )
@@ -1354,9 +1307,8 @@ def send_keeping_token_to_eoa_xdai(
 
 def get_buy_outcome_token_amount(
     investment_amount: CollateralToken,
-    buy_direction: bool,
-    yes_outcome_pool_size: OutcomeToken,
-    no_outcome_pool_size: OutcomeToken,
+    outcome_index: int,
+    pool_balances: list[OutcomeToken],
     fees: MarketFees,
 ) -> OutcomeToken:
     """
@@ -1364,19 +1316,24 @@ def get_buy_outcome_token_amount(
 
     Taken from https://github.com/gnosis/conditional-tokens-market-makers/blob/6814c0247c745680bb13298d4f0dd7f5b574d0db/contracts/FixedProductMarketMaker.sol#L264
     """
+    if outcome_index >= len(pool_balances):
+        raise ValueError("invalid outcome index")
+
     investment_amount_minus_fees = fees.get_after_fees(investment_amount)
     investment_amount_minus_fees_as_ot = OutcomeToken(
         investment_amount_minus_fees.value
     )
-    buy_token_pool_balance = (
-        yes_outcome_pool_size if buy_direction else no_outcome_pool_size
-    )
 
-    pool_balance = no_outcome_pool_size if buy_direction else yes_outcome_pool_size
-    denominator = pool_balance + investment_amount_minus_fees_as_ot
-    ending_outcome_balance = OutcomeToken(
-        buy_token_pool_balance * pool_balance / denominator
-    )
+    buy_token_pool_balance = pool_balances[outcome_index]
+    ending_outcome_balance = buy_token_pool_balance
+
+    # Calculate the ending balance considering all other outcomes
+    for i, pool_balance in enumerate(pool_balances):
+        if i != outcome_index:
+            denominator = pool_balance + investment_amount_minus_fees_as_ot
+            ending_outcome_balance = OutcomeToken(
+                (ending_outcome_balance * pool_balance / denominator)
+            )
 
     if ending_outcome_balance <= 0:
         raise ValueError("must have non-zero balances")

prediction_market_agent_tooling/markets/omen/omen_contracts.py

@@ -697,21 +697,18 @@ class OmenRealitioContract(ContractOnGnosisChain):
         self,
         api_keys: APIKeys,
         question_id: HexBytes,
-        answer: str,
-        outcomes: t.Sequence[str],
+        outcome_index: int,
         bond: xDaiWei,
         max_previous: xDaiWei | None = None,
         web3: Web3 | None = None,
     ) -> TxReceipt:
         # Normalise the answer to lowercase, to match Enum values as [YES, NO] against outcomes as ["Yes", "No"].
-        answer = answer.lower()
-        outcomes = [o.lower() for o in outcomes]
 
         return self.submitAnswer(
             api_keys=api_keys,
             question_id=question_id,
             answer=int_to_hexbytes(
-                outcomes.index(answer)
+                outcome_index
             ),  # Contract's method expects answer index in bytes.
             bond=bond,
             max_previous=max_previous,

prediction_market_agent_tooling/markets/omen/omen_resolving.py

@@ -10,7 +10,7 @@ from prediction_market_agent_tooling.gtypes import (
 )
 from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.markets.data_models import Resolution
-from prediction_market_agent_tooling.markets.manifold.utils import (
+from prediction_market_agent_tooling.markets.manifold.api import (
     find_resolution_on_manifold,
 )
 from prediction_market_agent_tooling.markets.markets import MarketType
@@ -168,28 +168,28 @@ def finalize_markets(
                     f"Skipping, no resolution provided, market closed before {closed_before_days} days: {market.url=}"
                 )
 
-        elif resolution in (Resolution.YES, Resolution.NO):
-            logger.info(f"Found resolution {resolution.value=} for {market.url=}")
-            omen_submit_answer_market_tx(
+        elif resolution.invalid:
+            logger.warning(
+                f"Invalid resolution found, {resolution=}, for {market.url=}, finalizing as invalid."
+            )
+            omen_submit_invalid_answer_market_tx(
                 api_keys,
                 market,
-                resolution,
                 realitio_bond,
                 web3=web3,
             )
-            finalized_markets.append(market.id)
-            logger.info(f"Finalized {market.url=}")
 
         else:
-            logger.warning(
-                f"Invalid resolution found, {resolution=}, for {market.url=}, finalizing as invalid."
-            )
-            omen_submit_invalid_answer_market_tx(
+            logger.info(f"Found resolution {resolution=} for {market.url=}")
+            omen_submit_answer_market_tx(
                 api_keys,
                 market,
+                resolution,
                 realitio_bond,
                 web3=web3,
             )
+            finalized_markets.append(market.id)
+            logger.info(f"Finalized {market.url=}")
 
     return finalized_markets
 
@@ -223,11 +223,11 @@ def omen_submit_answer_market_tx(
     And after the period is over, you need to resolve the market using `omen_resolve_market_tx`.
     """
     realitio_contract = OmenRealitioContract()
+    outcome_index = market.outcomes.index(resolution.outcome)
     realitio_contract.submit_answer(
         api_keys=api_keys,
         question_id=market.question.id,
-        answer=resolution.value,
-        outcomes=market.question.outcomes,
+        outcome_index=outcome_index,
         bond=bond.as_xdai_wei,
         web3=web3,
     )

prediction_market_agent_tooling/markets/omen/omen_subgraph_handler.py

@@ -23,7 +23,6 @@ from prediction_market_agent_tooling.markets.omen.data_models import (
     OmenMarket,
     OmenPosition,
     OmenUserPosition,
-    OutcomeStr,
     OutcomeWei,
     RealityAnswer,
     RealityQuestion,
@@ -221,7 +220,6 @@ class OmenSubgraphHandler(BaseSubgraphHandler):
         self,
         creator: HexAddress | None,
         creator_in: t.Sequence[HexAddress] | None,
-        outcomes: t.Sequence[OutcomeStr],
         created_after: DatetimeUTC | None,
         question_opened_before: DatetimeUTC | None,
         question_opened_after: DatetimeUTC | None,
@@ -239,12 +237,15 @@ class OmenSubgraphHandler(BaseSubgraphHandler):
         id_in: list[str] | None,
         collateral_token_address_in: tuple[ChecksumAddress, ...] | None,
         category: str | None,
+        include_categorical_markets: bool = False,
     ) -> dict[str, t.Any]:
         where_stms: dict[str, t.Any] = {
-            "outcomes": outcomes,
             "title_not": None,
             "condition_": {},
         }
+        if not include_categorical_markets:
+            where_stms["outcomeSlotCount"] = 2
+            where_stms["outcomes"] = OMEN_BINARY_MARKET_OUTCOMES
 
         where_stms["question_"] = self.get_omen_question_filters(
             question_id=question_id,
@@ -329,12 +330,13 @@ class OmenSubgraphHandler(BaseSubgraphHandler):
 
         return sort_direction, sort_by_field
 
-    def get_omen_binary_markets_simple(
+    def get_omen_markets_simple(
         self,
         limit: t.Optional[int],
         # Enumerated values for simpler usage.
         filter_by: FilterBy,
         sort_by: SortBy,
+        include_categorical_markets: bool = False,
         # Additional filters, these can not be modified by the enums above.
         created_after: DatetimeUTC | None = None,
         excluded_questions: set[str] | None = None,  # question titles
@@ -345,7 +347,7 @@ class OmenSubgraphHandler(BaseSubgraphHandler):
         creator_in: t.Sequence[HexAddress] | None = None,
     ) -> t.List[OmenMarket]:
         """
-        Simplified `get_omen_binary_markets` method, which allows to fetch markets based on the filter_by and sort_by values.
+        Simplified `get_omen_markets` method, which allows to fetch markets based on the filter_by and sort_by values.
         """
         # These values need to be set according to the filter_by value, so they can not be passed as arguments.
         resolved: bool | None = None
@@ -367,7 +369,7 @@ class OmenSubgraphHandler(BaseSubgraphHandler):
 
         sort_direction, sort_by_field = self._build_sort_params(sort_by)
 
-        return self.get_omen_binary_markets(
+        all_markets = self.get_omen_markets(
             limit=limit,
             resolved=resolved,
             question_opened_after=opened_after,
@@ -379,9 +381,12 @@ class OmenSubgraphHandler(BaseSubgraphHandler):
             collateral_token_address_in=collateral_token_address_in,
             category=category,
             creator_in=creator_in,
+            include_categorical_markets=include_categorical_markets,
         )
 
-    def get_omen_binary_markets(
+        return all_markets
+
+    def get_omen_markets(
         self,
         limit: t.Optional[int],
         creator: HexAddress | None = None,
@@ -403,19 +408,18 @@ class OmenSubgraphHandler(BaseSubgraphHandler):
         id_in: list[str] | None = None,
         sort_by_field: FieldPath | None = None,
         sort_direction: str | None = None,
-        outcomes: t.Sequence[OutcomeStr] = OMEN_BINARY_MARKET_OUTCOMES,
         collateral_token_address_in: (
             tuple[ChecksumAddress, ...] | None
         ) = SAFE_COLLATERAL_TOKENS_ADDRESSES,
         category: str | None = None,
+        include_categorical_markets: bool = True,
     ) -> t.List[OmenMarket]:
         """
-        Complete method to fetch Omen binary markets with various filters, use `get_omen_binary_markets_simple` for simplified version that uses FilterBy and SortBy enums.
+        Complete method to fetch Omen  markets with various filters, use `get_omen_markets_simple` for simplified version that uses FilterBy and SortBy enums.
         """
         where_stms = self._build_where_statements(
             creator=creator,
             creator_in=creator_in,
-            outcomes=outcomes,
             created_after=created_after,
             question_opened_before=question_opened_before,
             question_opened_after=question_opened_after,
@@ -433,6 +437,7 @@ class OmenSubgraphHandler(BaseSubgraphHandler):
             liquidity_bigger_than=liquidity_bigger_than,
             collateral_token_address_in=collateral_token_address_in,
             category=category,
+            include_categorical_markets=include_categorical_markets,
         )
 
         # These values can not be set to `None`, but they can be omitted.
@@ -451,6 +456,7 @@ class OmenSubgraphHandler(BaseSubgraphHandler):
         )
 
         fields = self._get_fields_for_markets(markets)
+
         omen_markets = self.do_query(fields=fields, pydantic_model=OmenMarket)
         return omen_markets
 
@@ -914,7 +920,7 @@ class OmenSubgraphHandler(BaseSubgraphHandler):
         unique_condition_ids: list[HexBytes] = list(
             set(sum([u.position.conditionIds for u in user_positions], []))
         )
-        markets = self.get_omen_binary_markets(
+        markets = self.get_omen_markets(
             limit=sys.maxsize, condition_id_in=unique_condition_ids
         )
         return markets
@@ -924,7 +930,7 @@ class OmenSubgraphHandler(BaseSubgraphHandler):
     ) -> OmenMarket:
         """Markets and user positions are uniquely connected via condition_ids"""
         condition_ids = user_position.position.conditionIds
-        markets = self.get_omen_binary_markets(limit=1, condition_id_in=condition_ids)
+        markets = self.get_omen_markets(limit=1, condition_id_in=condition_ids)
         if len(markets) != 1:
             raise ValueError(
                 f"Incorrect number of markets fetched {len(markets)}, expected 1."

prediction_market_agent_tooling/markets/polymarket/data_models.py

@@ -69,17 +69,21 @@ class PolymarketMarket(BaseModel):
     def resolution(self) -> Resolution | None:
         winner_tokens = [token for token in self.tokens if token.winner]
         if len(winner_tokens) == 0:
-            return None
+            return Resolution(outcome=None, invalid=True)
         elif (
             len(winner_tokens) == 1
             and winner_tokens[0].outcome == POLYMARKET_TRUE_OUTCOME
         ):
-            return Resolution.YES
+            return Resolution(
+                outcome=OutcomeStr(POLYMARKET_TRUE_OUTCOME), invalid=False
+            )
         elif (
             len(winner_tokens) == 1
             and winner_tokens[0].outcome == POLYMARKET_FALSE_OUTCOME
         ):
-            return Resolution.NO
+            return Resolution(
+                outcome=OutcomeStr(POLYMARKET_FALSE_OUTCOME), invalid=False
+            )
         else:
             raise ValueError(
                 f"Should not happen, invalid winner tokens: {winner_tokens}"