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

prediction_market_agent_tooling/markets/polymarket/data_models_web.py

@@ -181,19 +181,23 @@ class Market(BaseModel):
             zip(self.outcomes, self.outcomePrices)
         )
 
-        # On Polymarket, we can find out binary market resolution by by checking for the outcome prices.
+        # On Polymarket, we can find out binary market resolution by checking for the outcome prices.
         # E.g. if `Yes` price (probability) is 1$ and `No` price (probability) is 0$, it means the resolution is `Yes`.
         if (
             outcome_to_outcome_price[POLYMARKET_TRUE_OUTCOME] == 1.0
             and outcome_to_outcome_price[POLYMARKET_FALSE_OUTCOME] == 0.0
         ):
-            return Resolution.YES
+            return Resolution(
+                outcome=OutcomeStr(POLYMARKET_TRUE_OUTCOME), invalid=False
+            )
 
         elif (
             outcome_to_outcome_price[POLYMARKET_TRUE_OUTCOME] == 0.0
             and outcome_to_outcome_price[POLYMARKET_FALSE_OUTCOME] == 1.0
         ):
-            return Resolution.NO
+            return Resolution(
+                outcome=OutcomeStr(POLYMARKET_FALSE_OUTCOME), invalid=False
+            )
 
         else:
             raise ValueError(

prediction_market_agent_tooling/markets/polymarket/polymarket.py

@@ -1,6 +1,6 @@
 import typing as t
 
-from prediction_market_agent_tooling.gtypes import USD, CollateralToken
+from prediction_market_agent_tooling.gtypes import USD, CollateralToken, OutcomeStr
 from prediction_market_agent_tooling.markets.agent_market import (
     AgentMarket,
     FilterBy,
@@ -40,27 +40,28 @@ class PolymarketAgentMarket(AgentMarket):
             description=model.description,
             outcomes=[x.outcome for x in model.tokens],
             resolution=model.resolution,
-            current_p_yes=model.p_yes,
             created_time=None,
             close_time=model.end_date_iso,
             url=model.url,
             volume=None,
             outcome_token_pool=None,
+            probabilities={},  # ToDo - Implement when fixing Polymarket
         )
 
     def get_tiny_bet_amount(self) -> CollateralToken:
         raise NotImplementedError("TODO: Implement to allow betting on Polymarket.")
 
-    def place_bet(self, outcome: bool, amount: USD) -> str:
+    def place_bet(self, outcome: OutcomeStr, amount: USD) -> str:
         raise NotImplementedError("TODO: Implement to allow betting on Polymarket.")
 
     @staticmethod
-    def get_binary_markets(
+    def get_markets(
         limit: int,
         sort_by: SortBy = SortBy.NONE,
         filter_by: FilterBy = FilterBy.OPEN,
         created_after: t.Optional[DatetimeUTC] = None,
         excluded_questions: set[str] | None = None,
+        fetch_categorical_markets: bool = False,
     ) -> t.Sequence["PolymarketAgentMarket"]:
         if sort_by != SortBy.NONE:
             raise ValueError(f"Unsuported sort_by {sort_by} for Polymarket.")

prediction_market_agent_tooling/markets/seer/data_models.py

@@ -1,6 +1,4 @@
-import re
 import typing as t
-from enum import Enum
 from urllib.parse import urljoin
 
 from pydantic import BaseModel, ConfigDict, Field
@@ -16,7 +14,6 @@ from prediction_market_agent_tooling.gtypes import (
     OutcomeWei,
     Web3Wei,
 )
-from prediction_market_agent_tooling.markets.data_models import Resolution
 from prediction_market_agent_tooling.markets.seer.subgraph_data_models import (
     SeerParentMarket,
 )
@@ -47,44 +44,6 @@ class CreateCategoricalMarketsParams(BaseModel):
     token_names: list[str] = Field(..., alias="tokenNames")
 
 
-class SeerOutcomeEnum(str, Enum):
-    YES = "yes"
-    NO = "no"
-    INVALID = "invalid"
-
-    @classmethod
-    def from_bool(cls, value: bool) -> "SeerOutcomeEnum":
-        return cls.YES if value else cls.NO
-
-    @classmethod
-    def from_string(cls, value: str) -> "SeerOutcomeEnum":
-        """Convert a string (case-insensitive) to an Outcome enum."""
-        normalized = value.strip().lower()
-        patterns = {
-            r"^yes$": cls.YES,
-            r"^no$": cls.NO,
-            r"^(invalid|invalid result)$": cls.INVALID,
-        }
-
-        # Search through patterns and return the first match
-        for pattern, outcome in patterns.items():
-            if re.search(pattern, normalized):
-                return outcome
-
-        raise ValueError(f"Could not map {value=} to an outcome.")
-
-    def to_bool(self) -> bool:
-        """Convert a SeerOutcomeEnum to a boolean value."""
-        if self == self.YES:
-            return True
-        elif self == self.NO:
-            return False
-        elif self == self.INVALID:
-            raise ValueError("Cannot convert INVALID outcome to boolean.")
-        else:
-            raise ValueError(f"Unknown outcome: {self}")
-
-
 SEER_BASE_URL = "https://app.seer.pm"
 
 
@@ -115,22 +74,8 @@ class SeerMarket(BaseModel):
         # 1. An invalid outcome AND
         # 2. Invalid payoutNumerator is 1.
 
-        try:
-            self.outcome_as_enums[SeerOutcomeEnum.INVALID]
-        except KeyError:
-            raise ValueError(
-                f"Market {self.id.hex()} has no invalid outcome. {self.outcomes}"
-            )
-
         return self.payout_reported and self.payout_numerators[-1] != 1
 
-    @property
-    def outcome_as_enums(self) -> dict[SeerOutcomeEnum, int]:
-        return {
-            SeerOutcomeEnum.from_string(outcome): idx
-            for idx, outcome in enumerate(self.outcomes)
-        }
-
     @property
     def is_resolved(self) -> bool:
         return self.payout_reported
@@ -139,18 +84,6 @@ class SeerMarket(BaseModel):
     def is_resolved_with_valid_answer(self) -> bool:
         return self.is_resolved and self.has_valid_answer
 
-    def get_resolution_enum(self) -> t.Optional[Resolution]:
-        if not self.is_resolved_with_valid_answer:
-            return None
-
-        max_idx = self.payout_numerators.index(1)
-
-        outcome: str = self.outcomes[max_idx]
-        outcome_enum = SeerOutcomeEnum.from_string(outcome)
-        if outcome_enum.to_bool():
-            return Resolution.YES
-        return Resolution.NO
-
     def is_redeemable(self, owner: ChecksumAddress, web3: Web3 | None = None) -> bool:
         token_balances = self.get_outcome_token_balances(owner, web3)
         if not self.payout_reported:
@@ -177,22 +110,6 @@ class SeerMarket(BaseModel):
         # 3 because Seer has also third, `Invalid` outcome.
         return len(self.outcomes) == 3
 
-    def boolean_outcome_from_answer(self, answer: HexBytes) -> bool:
-        if not self.is_binary:
-            raise ValueError(
-                f"Market with title {self.title} is not binary, it has {len(self.outcomes)} outcomes."
-            )
-
-        outcome: str = self.outcomes[answer.as_int()]
-        outcome_enum = SeerOutcomeEnum.from_string(outcome)
-        return outcome_enum.to_bool()
-
-    def get_resolution_enum_from_answer(self, answer: HexBytes) -> Resolution:
-        if self.boolean_outcome_from_answer(answer):
-            return Resolution.YES
-        else:
-            return Resolution.NO
-
     @property
     def collateral_token_contract_address_checksummed(self) -> ChecksumAddress:
         return Web3.to_checksum_address(self.collateral_token)

prediction_market_agent_tooling/markets/seer/price_manager.py

@@ -6,13 +6,12 @@ from web3 import Web3
 from prediction_market_agent_tooling.gtypes import (
     ChecksumAddress,
     CollateralToken,
+    HexAddress,
+    OutcomeStr,
     Probability,
 )
 from prediction_market_agent_tooling.loggers import logger
-from prediction_market_agent_tooling.markets.seer.data_models import (
-    SeerMarket,
-    SeerOutcomeEnum,
-)
+from prediction_market_agent_tooling.markets.seer.data_models import SeerMarket
 from prediction_market_agent_tooling.markets.seer.seer_subgraph_handler import (
     SeerSubgraphHandler,
 )
@@ -65,30 +64,6 @@ class PriceManager:
                 f"{price_diff_pct=} larger than {max_price_diff=} for seer market {self.seer_market.id.hex()} "
             )
 
-    def current_p_yes(self) -> Probability | None:
-        # Inspired by https://github.com/seer-pm/demo/blob/ca682153a6b4d4dd3dcc4ad8bdcbe32202fc8fe7/web/src/hooks/useMarketOdds.ts#L15
-        price_data: dict[int, CollateralToken | None] = {}
-        for idx, wrapped_token in enumerate(self.seer_market.wrapped_tokens):
-            price = self.get_price_for_token(
-                token=Web3.to_checksum_address(wrapped_token),
-            )
-
-            price_data[idx] = price
-
-        price_yes = price_data[self.seer_market.outcome_as_enums[SeerOutcomeEnum.YES]]
-        price_no = price_data[self.seer_market.outcome_as_enums[SeerOutcomeEnum.NO]]
-
-        # We only return a probability if we have both price_yes and price_no, since we could place bets
-        # in both sides hence we need current probabilities for both outcomes.
-        if price_yes is not None and price_no is not None:
-            normalized_price_yes = price_yes / (price_yes + price_no)
-            self._log_track_price_normalization_diff(
-                old_price=price_yes.value, normalized_price=normalized_price_yes
-            )
-            return Probability(normalized_price_yes)
-        else:
-            return None
-
     @cached(TTLCache(maxsize=100, ttl=5 * 60), key=_make_cache_key)
     def get_price_for_token(
         self,
@@ -117,7 +92,7 @@ class PriceManager:
             return self.get_token_price_from_pools(token=token)
 
     @staticmethod
-    def _pool_token0_matches_token(token: ChecksumAddress, pool: SeerPool) -> bool:
+    def pool_token0_matches_token(token: ChecksumAddress, pool: SeerPool) -> bool:
         return pool.token0.id.hex().lower() == token.lower()
 
     def get_token_price_from_pools(
@@ -138,7 +113,46 @@ class PriceManager:
         # For example, in a outcomeYES (token0)/sDAI pool (token1), token1Price is the price of outcomeYES in units of sDAI.
         price = (
             pool.token1Price
-            if self._pool_token0_matches_token(token=token, pool=pool)
+            if self.pool_token0_matches_token(token=token, pool=pool)
             else pool.token0Price
         )
         return price
+
+    def build_probability_map(self) -> dict[OutcomeStr, Probability]:
+        # Inspired by https://github.com/seer-pm/demo/blob/ca682153a6b4d4dd3dcc4ad8bdcbe32202fc8fe7/web/src/hooks/useMarketOdds.ts#L15
+        price_data: dict[HexAddress, CollateralToken] = {}
+
+        for wrapped_token in self.seer_market.wrapped_tokens:
+            price = self.get_price_for_token(
+                token=Web3.to_checksum_address(wrapped_token),
+            )
+            price_data[wrapped_token] = (
+                price if price is not None else CollateralToken.zero()
+            )
+
+        # We normalize the prices to sum up to 1.
+        normalized_prices = {}
+
+        if not price_data or (
+            sum(price_data.values(), start=CollateralToken.zero())
+            == CollateralToken.zero()
+        ):
+            return {
+                OutcomeStr(outcome): Probability(0)
+                for outcome in self.seer_market.outcomes
+            }
+
+        for outcome_token, price in price_data.items():
+            old_price = price
+            new_price = Probability(
+                price / (sum(price_data.values(), start=CollateralToken.zero()))
+            )
+            self._log_track_price_normalization_diff(
+                old_price=old_price.value, normalized_price=new_price
+            )
+            outcome = self.seer_market.outcomes[
+                self.seer_market.wrapped_tokens.index(outcome_token)
+            ]
+            normalized_prices[OutcomeStr(outcome)] = new_price
+
+        return normalized_prices

prediction_market_agent_tooling/markets/seer/seer.py

@@ -1,6 +1,5 @@
 import typing as t
 
-from eth_pydantic_types import HexStr
 from eth_typing import ChecksumAddress
 from web3 import Web3
 from web3.types import TxReceipt
@@ -11,6 +10,7 @@ from prediction_market_agent_tooling.gtypes import (
     CollateralToken,
     HexAddress,
     HexBytes,
+    HexStr,
     OutcomeStr,
     OutcomeToken,
     OutcomeWei,
@@ -30,7 +30,6 @@ from prediction_market_agent_tooling.markets.omen.omen import OmenAgentMarket
 from prediction_market_agent_tooling.markets.seer.data_models import (
     RedeemParams,
     SeerMarket,
-    SeerOutcomeEnum,
 )
 from prediction_market_agent_tooling.markets.seer.price_manager import PriceManager
 from prediction_market_agent_tooling.markets.seer.seer_contracts import (
@@ -71,10 +70,10 @@ class SeerAgentMarket(AgentMarket):
     creator: HexAddress
     collateral_token_contract_address_checksummed: ChecksumAddress
     condition_id: HexBytes
-    seer_outcomes: dict[SeerOutcomeEnum, int]
     description: str | None = (
         None  # Seer markets don't have a description, so just default to None.
     )
+    outcomes_supply: int
 
     def get_collateral_token_contract(
         self, web3: Web3 | None = None
@@ -110,12 +109,17 @@ class SeerAgentMarket(AgentMarket):
         return get_usd_in_token(x, self.collateral_token_contract_address_checksummed)
 
     def get_buy_token_amount(
-        self, bet_amount: USD | CollateralToken, direction: bool
+        self, bet_amount: USD | CollateralToken, outcome_str: OutcomeStr
     ) -> OutcomeToken | None:
         """Returns number of outcome tokens returned for a given bet expressed in collateral units."""
 
-        outcome_str = self.get_outcome_str_from_bool(direction)
+        if outcome_str not in self.outcomes:
+            raise ValueError(
+                f"Outcome {outcome_str} not found in market outcomes {self.outcomes}"
+            )
+
         outcome_token = self.get_wrapped_token_for_outcome(outcome_str)
+
         bet_amount_in_tokens = self.get_in_token(bet_amount)
 
         p = PriceManager.build(market_id=HexBytes(HexStr(self.id)))
@@ -130,13 +134,12 @@ class SeerAgentMarket(AgentMarket):
         return OutcomeToken(amount_outcome_tokens)
 
     def get_sell_value_of_outcome_token(
-        self, outcome: str, amount: OutcomeToken
+        self, outcome: OutcomeStr, amount: OutcomeToken
     ) -> CollateralToken:
         if amount == amount.zero():
             return CollateralToken.zero()
 
-        outcome_index = self.get_outcome_index(outcome=outcome)
-        wrapped_outcome_token = self.wrapped_tokens[outcome_index]
+        wrapped_outcome_token = self.get_wrapped_token_for_outcome(outcome)
 
         # We calculate how much collateral we would get back if we sold `amount` of outcome token.
         value_outcome_token_in_collateral = get_buy_token_amount_else_raise(
@@ -146,11 +149,6 @@ class SeerAgentMarket(AgentMarket):
         )
         return value_outcome_token_in_collateral.as_token
 
-    def get_outcome_str_from_bool(self, outcome: bool) -> OutcomeStr:
-        outcome_translated = SeerOutcomeEnum.from_bool(outcome)
-        idx = self.seer_outcomes[outcome_translated]
-        return OutcomeStr(self.outcomes[idx])
-
     @staticmethod
     def get_trade_balance(api_keys: APIKeys) -> USD:
         return OmenAgentMarket.get_trade_balance(api_keys=api_keys)
@@ -168,17 +166,16 @@ class SeerAgentMarket(AgentMarket):
 
         amounts_ot: dict[OutcomeStr, OutcomeToken] = {}
 
-        for outcome in [True, False]:
-            outcome_str = self.get_outcome_str_from_bool(outcome)
-            wrapped_token = self.get_wrapped_token_for_outcome(outcome_str)
-
+        for outcome_str, wrapped_token in zip(self.outcomes, self.wrapped_tokens):
             outcome_token_balance_wei = OutcomeWei.from_wei(
                 ContractERC20OnGnosisChain(address=wrapped_token).balanceOf(
                     for_address=Web3.to_checksum_address(user_id), web3=web3
                 )
             )
-            outcome_str = self.get_outcome_str_from_bool(outcome=outcome)
-            amounts_ot[outcome_str] = outcome_token_balance_wei.as_outcome_token
+
+            amounts_ot[
+                OutcomeStr(outcome_str)
+            ] = outcome_token_balance_wei.as_outcome_token
 
         amounts_current = {
             k: self.get_token_in_usd(self.get_sell_value_of_outcome_token(k, v))
@@ -194,76 +191,6 @@ class SeerAgentMarket(AgentMarket):
             amounts_ot=amounts_ot,
         )
 
-    def get_outcome_str_from_idx(self, outcome_index: int) -> OutcomeStr:
-        return self.outcomes[outcome_index]
-
-    def get_liquidity_for_outcome(
-        self, outcome: OutcomeStr, web3: Web3 | None = None
-    ) -> CollateralToken:
-        """Liquidity per outcome is comprised of the balance of outcomeToken + collateralToken held by the pool itself (see https://github.com/seer-pm/demo/blob/7bfd0a062780ed6567f65714c4fc4f6e6cdf1c4f/web/netlify/functions/utils/fetchPools.ts#L35-L42)."""
-
-        outcome_token = self.get_wrapped_token_for_outcome(outcome)
-        pool = SeerSubgraphHandler().get_pool_by_token(
-            token_address=outcome_token,
-            collateral_address=self.collateral_token_contract_address_checksummed,
-        )
-        if not pool:
-            logger.info(
-                f"Could not fetch pool for token {outcome_token}, no liquidity available for outcome."
-            )
-            return CollateralToken(0)
-        p = PriceManager.build(HexBytes(HexStr(self.id)))
-        total = CollateralToken(0)
-
-        for token_address in [pool.token0.id, pool.token1.id]:
-            token_address_checksummed = Web3.to_checksum_address(token_address)
-            token_contract = ContractERC20OnGnosisChain(
-                address=token_address_checksummed
-            )
-
-            token_balance = token_contract.balance_of_in_tokens(
-                for_address=Web3.to_checksum_address(pool.id.hex()),
-                web3=web3,
-            )
-
-            # get price
-            token_price_in_sdai = (
-                p.get_token_price_from_pools(token=token_address_checksummed)
-                if token_address_checksummed
-                != self.collateral_token_contract_address_checksummed
-                else CollateralToken(1.0)
-            )
-
-            # We ignore the liquidity in outcome tokens if price unknown.
-            if token_price_in_sdai:
-                sdai_balance = token_balance * token_price_in_sdai
-                total += sdai_balance
-
-        return total
-
-    def get_liquidity(self) -> CollateralToken:
-        liquidity_in_collateral = CollateralToken(0)
-        # We ignore the invalid outcome
-        for outcome in self.outcomes[:-1]:
-            liquidity_for_outcome = self.get_liquidity_for_outcome(outcome)
-            liquidity_in_collateral += liquidity_for_outcome
-
-        return liquidity_in_collateral
-
-    def has_liquidity_for_outcome(self, outcome: OutcomeStr) -> bool:
-        liquidity = self.get_liquidity_for_outcome(outcome)
-        return liquidity > CollateralToken(0)
-
-    def has_liquidity(self) -> bool:
-        # We define a market as having liquidity if it has liquidity for all outcomes except for the invalid (index -1)
-        return all(
-            [self.has_liquidity_for_outcome(outcome) for outcome in self.outcomes[:-1]]
-        )
-
-    def get_wrapped_token_for_outcome(self, outcome: OutcomeStr) -> ChecksumAddress:
-        outcome_idx = self.outcomes.index(outcome)
-        return self.wrapped_tokens[outcome_idx]
-
     def get_position(
         self, user_id: str, web3: Web3 | None = None
     ) -> ExistingPosition | None:
@@ -307,7 +234,7 @@ class SeerAgentMarket(AgentMarket):
         web3 = RPCConfig().get_web3()
         subgraph = SeerSubgraphHandler()
 
-        closed_markets = subgraph.get_binary_markets(
+        closed_markets = subgraph.get_markets(
             filter_by=FilterBy.RESOLVED, sort_by=SortBy.NEWEST
         )
         filtered_markets = SeerAgentMarket._filter_markets_contained_in_trades(
@@ -351,10 +278,11 @@ class SeerAgentMarket(AgentMarket):
         model: SeerMarket, seer_subgraph: SeerSubgraphHandler
     ) -> t.Optional["SeerAgentMarket"]:
         p = PriceManager(seer_market=model, seer_subgraph=seer_subgraph)
-        current_p_yes = p.current_p_yes()
-        if not current_p_yes:
+
+        probability_map = p.build_probability_map()
+        if not probability_map:
             logger.info(
-                f"p_yes for market {model.id.hex()} could not be calculated. Skipping."
+                f"probability_map for market {model.id.hex()} could not be calculated. Skipping."
             )
             return None
 
@@ -371,23 +299,27 @@ class SeerAgentMarket(AgentMarket):
             wrapped_tokens=[Web3.to_checksum_address(i) for i in model.wrapped_tokens],
             fees=MarketFees.get_zero_fees(),
             outcome_token_pool=None,
-            resolution=model.get_resolution_enum(),
+            outcomes_supply=model.outcomes_supply,
+            resolution=None,
             volume=None,
-            current_p_yes=current_p_yes,
-            seer_outcomes=model.outcome_as_enums,
+            probabilities=probability_map,
         )
 
     @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["SeerAgentMarket"]:
         seer_subgraph = SeerSubgraphHandler()
-        markets = seer_subgraph.get_binary_markets(
-            limit=limit, sort_by=sort_by, filter_by=filter_by
+        markets = seer_subgraph.get_markets(
+            limit=limit,
+            sort_by=sort_by,
+            filter_by=filter_by,
+            include_categorical_markets=fetch_categorical_markets,
         )
 
         # We exclude the None values below because `from_data_model_with_subgraph` can return None, which
@@ -403,9 +335,79 @@ class SeerAgentMarket(AgentMarket):
             is not None
         ]
 
+    def get_outcome_str_from_idx(self, outcome_index: int) -> OutcomeStr:
+        return self.outcomes[outcome_index]
+
+    def get_liquidity_for_outcome(
+        self, outcome: OutcomeStr, web3: Web3 | None = None
+    ) -> CollateralToken:
+        """Liquidity per outcome is comprised of the balance of outcomeToken + collateralToken held by the pool itself (see https://github.com/seer-pm/demo/blob/7bfd0a062780ed6567f65714c4fc4f6e6cdf1c4f/web/netlify/functions/utils/fetchPools.ts#L35-L42)."""
+
+        outcome_token = self.get_wrapped_token_for_outcome(outcome)
+        pool = SeerSubgraphHandler().get_pool_by_token(
+            token_address=outcome_token,
+            collateral_address=self.collateral_token_contract_address_checksummed,
+        )
+        if not pool:
+            logger.info(
+                f"Could not fetch pool for token {outcome_token}, no liquidity available for outcome."
+            )
+            return CollateralToken(0)
+        p = PriceManager.build(HexBytes(HexStr(self.id)))
+        total = CollateralToken(0)
+
+        for token_address in [pool.token0.id, pool.token1.id]:
+            token_address_checksummed = Web3.to_checksum_address(token_address)
+            token_contract = ContractERC20OnGnosisChain(
+                address=token_address_checksummed
+            )
+
+            token_balance = token_contract.balance_of_in_tokens(
+                for_address=Web3.to_checksum_address(HexAddress(HexStr(pool.id.hex()))),
+                web3=web3,
+            )
+
+            # get price
+            token_price_in_sdai = (
+                p.get_token_price_from_pools(token=token_address_checksummed)
+                if token_address_checksummed
+                != self.collateral_token_contract_address_checksummed
+                else CollateralToken(1.0)
+            )
+
+            # We ignore the liquidity in outcome tokens if price unknown.
+            if token_price_in_sdai:
+                sdai_balance = token_balance * token_price_in_sdai
+                total += sdai_balance
+
+        return total
+
+    def get_liquidity(self) -> CollateralToken:
+        liquidity_in_collateral = CollateralToken(0)
+        # We ignore the invalid outcome
+        for outcome in self.outcomes[:-1]:
+            liquidity_for_outcome = self.get_liquidity_for_outcome(outcome)
+            liquidity_in_collateral += liquidity_for_outcome
+
+        return liquidity_in_collateral
+
+    def has_liquidity_for_outcome(self, outcome: OutcomeStr) -> bool:
+        liquidity = self.get_liquidity_for_outcome(outcome)
+        return liquidity > CollateralToken(0)
+
+    def has_liquidity(self) -> bool:
+        # We define a market as having liquidity if it has liquidity for all outcomes except for the invalid (index -1)
+        return all(
+            [self.has_liquidity_for_outcome(outcome) for outcome in self.outcomes[:-1]]
+        )
+
+    def get_wrapped_token_for_outcome(self, outcome: OutcomeStr) -> ChecksumAddress:
+        outcome_idx = self.outcomes.index(outcome)
+        return self.wrapped_tokens[outcome_idx]
+
     def place_bet(
         self,
-        outcome: bool,
+        outcome: OutcomeStr,
         amount: USD,
         auto_deposit: bool = True,
         web3: Web3 | None = None,
@@ -432,8 +434,7 @@ class SeerAgentMarket(AgentMarket):
                 f"Balance {collateral_balance} not enough for bet size {amount}"
             )
 
-        outcome_str = self.get_outcome_str_from_bool(outcome)
-        outcome_token = self.get_wrapped_token_for_outcome(outcome_str)
+        outcome_token = self.get_wrapped_token_for_outcome(outcome)
 
         #  Sell sDAI using token address
         order_metadata = swap_tokens_waiting(
@@ -451,7 +452,7 @@ class SeerAgentMarket(AgentMarket):
 
     def sell_tokens(
         self,
-        outcome: bool,
+        outcome: OutcomeStr,
         amount: USD | OutcomeToken,
         auto_withdraw: bool = True,
         api_keys: APIKeys | None = None,
@@ -460,8 +461,7 @@ class SeerAgentMarket(AgentMarket):
         """
         Sells the given number of shares for the given outcome in the given market.
         """
-        outcome_str = self.get_outcome_str_from_bool(outcome)
-        outcome_token = self.get_wrapped_token_for_outcome(outcome_str)
+        outcome_token = self.get_wrapped_token_for_outcome(outcome)
         api_keys = api_keys if api_keys is not None else APIKeys()
 
         token_amount = (