prediction-market-agent-tooling 0.66.2__tar.gz → 0.66.4__tar.gz

{prediction_market_agent_tooling-0.66.2 → prediction_market_agent_tooling-0.66.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: prediction-market-agent-tooling
-Version: 0.66.2
+Version: 0.66.4
 Summary: Tools to benchmark, deploy and monitor prediction market agents.
 Author: Gnosis
 Requires-Python: >=3.10,<3.13

{prediction_market_agent_tooling-0.66.2 → prediction_market_agent_tooling-0.66.4}/prediction_market_agent_tooling/benchmark/utils.py

@@ -6,6 +6,7 @@ from pydantic import BaseModel
 from prediction_market_agent_tooling.gtypes import OutcomeStr, Probability
 from prediction_market_agent_tooling.markets.data_models import (
     CategoricalProbabilisticAnswer,
+    ScalarProbabilisticAnswer,
 )
 
 
@@ -16,6 +17,18 @@ def get_most_probable_outcome(
     return max(probability_map, key=lambda k: float(probability_map[k]))
 
 
+class ScalarPrediction(BaseModel):
+    is_predictable: bool = True
+    outcome_prediction: t.Optional[ScalarProbabilisticAnswer] = None
+
+    time: t.Optional[float] = None
+    cost: t.Optional[float] = None
+
+    @property
+    def is_answered(self) -> bool:
+        return self.outcome_prediction is not None
+
+
 class Prediction(BaseModel):
     is_predictable: bool = True
     outcome_prediction: t.Optional[CategoricalProbabilisticAnswer] = None

{prediction_market_agent_tooling-0.66.2 → prediction_market_agent_tooling-0.66.4}/prediction_market_agent_tooling/deploy/agent.py

@@ -31,6 +31,7 @@ from prediction_market_agent_tooling.markets.data_models import (
     ExistingPosition,
     PlacedTrade,
     ProbabilisticAnswer,
+    ScalarProbabilisticAnswer,
     Trade,
 )
 from prediction_market_agent_tooling.markets.markets import MarketType
@@ -219,6 +220,7 @@ class DeployablePredictionAgent(DeployableAgent):
         self.verify_market = observe()(self.verify_market)  # type: ignore[method-assign]
         self.answer_binary_market = observe()(self.answer_binary_market)  # type: ignore[method-assign]
         self.answer_categorical_market = observe()(self.answer_categorical_market)  # type: ignore[method-assign]
+        self.answer_scalar_market = observe()(self.answer_scalar_market)  # type: ignore[method-assign]
         self.process_market = observe()(self.process_market)  # type: ignore[method-assign]
 
     def update_langfuse_trace_by_market(
@@ -299,6 +301,11 @@ class DeployablePredictionAgent(DeployableAgent):
     ) -> CategoricalProbabilisticAnswer | None:
         raise NotImplementedError("This method must be implemented by the subclass")
 
+    def answer_scalar_market(
+        self, market: AgentMarket
+    ) -> ScalarProbabilisticAnswer | None:
+        raise NotImplementedError("This method must be implemented by the subclass")
+
     def answer_binary_market(self, market: AgentMarket) -> ProbabilisticAnswer | None:
         """
         Answer the binary market.
@@ -321,6 +328,13 @@ class DeployablePredictionAgent(DeployableAgent):
             return True
         return False
 
+    @property
+    def fetch_scalar_markets(self) -> bool:
+        # Check if the subclass has implemented the answer_scalar_market method, if yes, fetch scalar markets as well.
+        if self.answer_scalar_market.__wrapped__.__func__ is not DeployablePredictionAgent.answer_scalar_market:  # type: ignore[attr-defined] # This works just fine, but mypy doesn't know about it for some reason.
+            return True
+        return False
+
     def get_markets(
         self,
         market_type: MarketType,
@@ -336,6 +350,7 @@ class DeployablePredictionAgent(DeployableAgent):
             filter_by=self.get_markets_filter_by,
             created_after=self.trade_on_markets_created_after,
             fetch_categorical_markets=self.fetch_categorical_markets,
+            fetch_scalar_markets=self.fetch_scalar_markets,
         )
         return available_markets
 
@@ -383,7 +398,16 @@ class DeployablePredictionAgent(DeployableAgent):
                 logger.info(
                     "answer_binary_market() not implemented, falling back to answer_categorical_market()"
                 )
-
+        elif market.is_scalar:
+            scalar_answer = self.answer_scalar_market(market)
+            return (
+                CategoricalProbabilisticAnswer.from_scalar_answer(
+                    scalar_answer,
+                    market.outcomes,
+                )
+                if scalar_answer is not None
+                else None
+            )
         return self.answer_categorical_market(market)
 
     def verify_answer_outcomes(

{prediction_market_agent_tooling-0.66.2 → prediction_market_agent_tooling-0.66.4}/prediction_market_agent_tooling/deploy/betting_strategy.py

@@ -40,6 +40,9 @@ class GuaranteedLossError(RuntimeError):
 
 
 class BettingStrategy(ABC):
+    def __init__(self, take_profit: bool = True) -> None:
+        self.take_profit = take_profit
+
     @abstractmethod
     def calculate_trades(
         self,
@@ -209,10 +212,22 @@ class BettingStrategy(ABC):
             )
 
             diff_amount = target_amount - existing_amount
+
             if diff_amount == 0:
                 continue
 
             trade_type = TradeType.SELL if diff_amount < 0 else TradeType.BUY
+
+            # We work with positions, so imagine following scenario: Agent invested $10 when probs were 50:50,
+            # now the probs are 99:1 and his initial $10 is worth $100.
+            # If `take_profit` is set to False, agent won't sell the $90 to get back to the $10 position.
+            if (
+                not self.take_profit
+                and target_amount > 0
+                and trade_type == TradeType.SELL
+            ):
+                continue
+
             trade = Trade(
                 amount=abs(diff_amount),
                 outcome=outcome,
@@ -231,7 +246,8 @@ class BettingStrategy(ABC):
 
 
 class MultiCategoricalMaxAccuracyBettingStrategy(BettingStrategy):
-    def __init__(self, max_position_amount: USD):
+    def __init__(self, max_position_amount: USD, take_profit: bool = True):
+        super().__init__(take_profit=take_profit)
         self.max_position_amount = max_position_amount
 
     @property
@@ -336,7 +352,13 @@ class MaxExpectedValueBettingStrategy(MultiCategoricalMaxAccuracyBettingStrategy
 
 
 class KellyBettingStrategy(BettingStrategy):
-    def __init__(self, max_position_amount: USD, max_price_impact: float | None = None):
+    def __init__(
+        self,
+        max_position_amount: USD,
+        max_price_impact: float | None = None,
+        take_profit: bool = True,
+    ):
+        super().__init__(take_profit=take_profit)
         self.max_position_amount = max_position_amount
         self.max_price_impact = max_price_impact
 
@@ -492,7 +514,12 @@ class KellyBettingStrategy(BettingStrategy):
 
 
 class MaxAccuracyWithKellyScaledBetsStrategy(BettingStrategy):
-    def __init__(self, max_position_amount: USD):
+    def __init__(
+        self,
+        max_position_amount: USD,
+        take_profit: bool = True,
+    ):
+        super().__init__(take_profit)
         self.max_position_amount = max_position_amount
 
     @property

{prediction_market_agent_tooling-0.66.2 → prediction_market_agent_tooling-0.66.4}/prediction_market_agent_tooling/deploy/constants.py

@@ -5,3 +5,5 @@ INVALID_OUTCOME_LOWERCASE_IDENTIFIER = "invalid"
 # Market-agnostic outcome identifiers
 YES_OUTCOME_LOWERCASE_IDENTIFIER = "yes"
 NO_OUTCOME_LOWERCASE_IDENTIFIER = "no"
+UP_OUTCOME_LOWERCASE_IDENTIFIER = "up"
+DOWN_OUTCOME_LOWERCASE_IDENTIFIER = "down"

{prediction_market_agent_tooling-0.66.2 → prediction_market_agent_tooling-0.66.4}/prediction_market_agent_tooling/jobs/omen/omen_jobs.py

@@ -133,4 +133,6 @@ class OmenJobAgentMarket(OmenAgentMarket, JobAgentMarket):
             condition=market.condition,
             finalized_time=market.finalized_time,
             fees=market.fees,
+            upper_bound=market.upper_bound,
+            lower_bound=market.lower_bound,
         )

{prediction_market_agent_tooling-0.66.2 → prediction_market_agent_tooling-0.66.4}/prediction_market_agent_tooling/markets/agent_market.py

@@ -11,8 +11,10 @@ from web3 import Web3
 from prediction_market_agent_tooling.benchmark.utils import get_most_probable_outcome
 from prediction_market_agent_tooling.config import APIKeys
 from prediction_market_agent_tooling.deploy.constants import (
+    DOWN_OUTCOME_LOWERCASE_IDENTIFIER,
     INVALID_OUTCOME_LOWERCASE_IDENTIFIER,
     NO_OUTCOME_LOWERCASE_IDENTIFIER,
+    UP_OUTCOME_LOWERCASE_IDENTIFIER,
     YES_OUTCOME_LOWERCASE_IDENTIFIER,
 )
 from prediction_market_agent_tooling.gtypes import (
@@ -20,6 +22,7 @@ from prediction_market_agent_tooling.gtypes import (
     OutcomeToken,
     OutcomeWei,
     Probability,
+    Wei,
 )
 from prediction_market_agent_tooling.markets.data_models import (
     USD,
@@ -83,6 +86,9 @@ class AgentMarket(BaseModel):
     volume: CollateralToken | None
     fees: MarketFees
 
+    upper_bound: Wei | None = None
+    lower_bound: Wei | None = None
+
     @field_validator("probabilities")
     def validate_probabilities(
         cls,
@@ -165,6 +171,34 @@ class AgentMarket(BaseModel):
 
         return has_yes and has_no
 
+    @property
+    def is_scalar(self) -> bool:
+        # 3 outcomes can also be binary if 3rd outcome is invalid (Seer)
+        if len(self.outcomes) not in [2, 3]:
+            return False
+
+        lowercase_outcomes = [outcome.lower() for outcome in self.outcomes]
+
+        has_up = UP_OUTCOME_LOWERCASE_IDENTIFIER in lowercase_outcomes
+        has_down = DOWN_OUTCOME_LOWERCASE_IDENTIFIER in lowercase_outcomes
+
+        if len(lowercase_outcomes) == 3:
+            invalid_outcome = lowercase_outcomes[-1]
+            has_invalid = INVALID_OUTCOME_LOWERCASE_IDENTIFIER in invalid_outcome
+            return has_up and has_down and has_invalid
+
+        return has_up and has_down
+
+    @property
+    def p_up(self) -> Probability:
+        probs_lowercase = {o.lower(): p for o, p in self.probabilities.items()}
+        return check_not_none(probs_lowercase.get(UP_OUTCOME_LOWERCASE_IDENTIFIER))
+
+    @property
+    def p_down(self) -> Probability:
+        probs_lowercase = {o.lower(): p for o, p in self.probabilities.items()}
+        return check_not_none(probs_lowercase.get(DOWN_OUTCOME_LOWERCASE_IDENTIFIER))
+
     @property
     def p_yes(self) -> Probability:
         probs_lowercase = {o.lower(): p for o, p in self.probabilities.items()}
@@ -336,6 +370,7 @@ class AgentMarket(BaseModel):
         created_after: t.Optional[DatetimeUTC] = None,
         excluded_questions: set[str] | None = None,
         fetch_categorical_markets: bool = False,
+        fetch_scalar_markets: bool = False,
     ) -> t.Sequence["AgentMarket"]:
         raise NotImplementedError("Subclasses must implement this method")
 

{prediction_market_agent_tooling-0.66.2 → prediction_market_agent_tooling-0.66.4}/prediction_market_agent_tooling/markets/data_models.py

@@ -4,7 +4,10 @@ from typing import Annotated, Sequence
 from pydantic import BaseModel, BeforeValidator, computed_field
 
 from prediction_market_agent_tooling.deploy.constants import (
+    DOWN_OUTCOME_LOWERCASE_IDENTIFIER,
+    INVALID_OUTCOME_LOWERCASE_IDENTIFIER,
     NO_OUTCOME_LOWERCASE_IDENTIFIER,
+    UP_OUTCOME_LOWERCASE_IDENTIFIER,
     YES_OUTCOME_LOWERCASE_IDENTIFIER,
 )
 from prediction_market_agent_tooling.gtypes import (
@@ -13,6 +16,7 @@ from prediction_market_agent_tooling.gtypes import (
     OutcomeStr,
     OutcomeToken,
     Probability,
+    Wei,
 )
 from prediction_market_agent_tooling.logprobs_parser import FieldLogprobs
 from prediction_market_agent_tooling.markets.omen.omen_constants import (
@@ -100,6 +104,31 @@ def to_boolean_outcome(value: str | bool) -> bool:
 Decision = Annotated[bool, BeforeValidator(to_boolean_outcome)]
 
 
+class ScalarProbabilisticAnswer(BaseModel):
+    scalar_value: Wei
+    upperBound: Wei
+    lowerBound: Wei
+    confidence: float
+    reasoning: str | None = None
+    logprobs: list[FieldLogprobs] | None = None
+
+    @property
+    def p_up(self) -> Probability:
+        if self.scalar_value > self.upperBound:
+            return Probability(1)
+        elif self.scalar_value < self.lowerBound:
+            return Probability(0)
+        else:
+            return Probability(
+                (self.scalar_value - self.lowerBound)
+                / (self.upperBound - self.lowerBound)
+            )
+
+    @property
+    def p_down(self) -> Probability:
+        return Probability(1 - self.p_up)
+
+
 class ProbabilisticAnswer(BaseModel):
     p_yes: Probability
     confidence: float
@@ -165,6 +194,41 @@ class CategoricalProbabilisticAnswer(BaseModel):
             reasoning=answer.reasoning,
         )
 
+    @staticmethod
+    def from_scalar_answer(
+        answer: ScalarProbabilisticAnswer,
+        market_outcomes: Sequence[OutcomeStr],
+    ) -> "CategoricalProbabilisticAnswer":
+        probabilities = {}
+        lowercase_market_outcomes = [outcome.lower() for outcome in market_outcomes]
+
+        if not set(
+            [
+                DOWN_OUTCOME_LOWERCASE_IDENTIFIER,
+                UP_OUTCOME_LOWERCASE_IDENTIFIER,
+            ]
+        ).issubset(lowercase_market_outcomes):
+            raise ValueError("Market with no outcomes")
+
+        probabilities[OutcomeStr(UP_OUTCOME_LOWERCASE_IDENTIFIER.upper())] = answer.p_up
+        probabilities[
+            OutcomeStr(DOWN_OUTCOME_LOWERCASE_IDENTIFIER.upper())
+        ] = answer.p_down
+
+        if (
+            market_outcomes
+            and INVALID_OUTCOME_LOWERCASE_IDENTIFIER in lowercase_market_outcomes
+        ):
+            probabilities[
+                OutcomeStr(INVALID_OUTCOME_LOWERCASE_IDENTIFIER.capitalize())
+            ] = Probability(1 - answer.p_up - answer.p_down)
+
+        return CategoricalProbabilisticAnswer(
+            probabilities=probabilities,
+            confidence=answer.confidence,
+            reasoning=answer.reasoning,
+        )
+
     def probability_for_market_outcome(self, market_outcome: OutcomeStr) -> Probability:
         for k, v in self.probabilities.items():
             if k.lower() == market_outcome.lower():

{prediction_market_agent_tooling-0.66.2 → prediction_market_agent_tooling-0.66.4}/prediction_market_agent_tooling/markets/manifold/manifold.py

@@ -111,6 +111,7 @@ class ManifoldAgentMarket(AgentMarket):
         created_after: t.Optional[DatetimeUTC] = None,
         excluded_questions: set[str] | None = None,
         fetch_categorical_markets: bool = False,
+        fetch_scalar_markets: bool = False,
     ) -> t.Sequence["ManifoldAgentMarket"]:
         sort: t.Literal["newest", "close-date"] | None
         if sort_by == SortBy.CLOSING_SOONEST:

{prediction_market_agent_tooling-0.66.2 → prediction_market_agent_tooling-0.66.4}/prediction_market_agent_tooling/markets/markets.py

@@ -68,6 +68,7 @@ def get_binary_markets(
     sort_by: SortBy = SortBy.NONE,
     excluded_questions: set[str] | None = None,
     created_after: DatetimeUTC | None = None,
+    fetch_scalar_markets: bool = False,
 ) -> t.Sequence[AgentMarket]:
     agent_market_class = MARKET_TYPE_TO_AGENT_MARKET[market_type]
     markets = agent_market_class.get_markets(
@@ -76,5 +77,6 @@ def get_binary_markets(
         filter_by=filter_by,
         created_after=created_after,
         excluded_questions=excluded_questions,
+        fetch_scalar_markets=fetch_scalar_markets,
     )
     return markets

{prediction_market_agent_tooling-0.66.2 → prediction_market_agent_tooling-0.66.4}/prediction_market_agent_tooling/markets/metaculus/metaculus.py

@@ -73,6 +73,7 @@ class MetaculusAgentMarket(AgentMarket):
         created_after: t.Optional[DatetimeUTC] = None,
         excluded_questions: set[str] | None = None,
         tournament_id: int | None = None,
+        fetch_scalar_markets: bool = False,
     ) -> t.Sequence["MetaculusAgentMarket"]:
         order_by: str | None
         if sort_by == SortBy.NONE:

{prediction_market_agent_tooling-0.66.2 → prediction_market_agent_tooling-0.66.4}/prediction_market_agent_tooling/markets/omen/omen.py

@@ -380,6 +380,7 @@ class OmenAgentMarket(AgentMarket):
         created_after: t.Optional[DatetimeUTC] = None,
         excluded_questions: set[str] | None = None,
         fetch_categorical_markets: bool = False,
+        fetch_scalar_markets: bool = False,
     ) -> t.Sequence["OmenAgentMarket"]:
         return [
             OmenAgentMarket.from_data_model(m)

{prediction_market_agent_tooling-0.66.2 → prediction_market_agent_tooling-0.66.4}/prediction_market_agent_tooling/markets/omen/omen_subgraph_handler.py

@@ -53,7 +53,7 @@ from prediction_market_agent_tooling.tools.web3_utils import (
     unwrap_generic_value,
 )
 
-SAFE_COLLATERAL_TOKENS = (
+SAFE_COLLATERAL_TOKENS = [
     WrappedxDaiContract(),
     sDaiContract(),
     GNOContract(),
@@ -62,10 +62,10 @@ SAFE_COLLATERAL_TOKENS = (
     SAFEContract(),
     COWContract(),
     MetriSuperGroup(),
-)
-SAFE_COLLATERAL_TOKENS_ADDRESSES = tuple(
+]
+SAFE_COLLATERAL_TOKENS_ADDRESSES = [
     contract.address for contract in SAFE_COLLATERAL_TOKENS
-)
+]
 
 
 class OmenSubgraphHandler(BaseSubgraphHandler):
@@ -237,7 +237,7 @@ class OmenSubgraphHandler(BaseSubgraphHandler):
         liquidity_bigger_than: Wei | None,
         condition_id_in: list[HexBytes] | None,
         id_in: list[str] | None,
-        collateral_token_address_in: tuple[ChecksumAddress, ...] | None,
+        collateral_token_address_in: t.Sequence[ChecksumAddress] | None,
         category: str | None,
         include_categorical_markets: bool = False,
         include_scalar_markets: bool = False,
@@ -348,7 +348,7 @@ class OmenSubgraphHandler(BaseSubgraphHandler):
         created_after: DatetimeUTC | None = None,
         excluded_questions: set[str] | None = None,  # question titles
         collateral_token_address_in: (
-            tuple[ChecksumAddress, ...] | None
+            t.Sequence[ChecksumAddress] | None
         ) = SAFE_COLLATERAL_TOKENS_ADDRESSES,
         category: str | None = None,
         creator_in: t.Sequence[HexAddress] | None = None,
@@ -416,7 +416,7 @@ class OmenSubgraphHandler(BaseSubgraphHandler):
         sort_by_field: FieldPath | None = None,
         sort_direction: str | None = None,
         collateral_token_address_in: (
-            tuple[ChecksumAddress, ...] | None
+            t.Sequence[ChecksumAddress] | None
         ) = SAFE_COLLATERAL_TOKENS_ADDRESSES,
         category: str | None = None,
         include_categorical_markets: bool = True,

{prediction_market_agent_tooling-0.66.2 → prediction_market_agent_tooling-0.66.4}/prediction_market_agent_tooling/markets/polymarket/polymarket.py

@@ -62,6 +62,7 @@ class PolymarketAgentMarket(AgentMarket):
         created_after: t.Optional[DatetimeUTC] = None,
         excluded_questions: set[str] | None = None,
         fetch_categorical_markets: bool = False,
+        fetch_scalar_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-0.66.2 → prediction_market_agent_tooling-0.66.4}/prediction_market_agent_tooling/markets/seer/data_models.py

@@ -1,8 +1,9 @@
 import typing as t
 from datetime import timedelta
+from typing import Annotated
 from urllib.parse import urljoin
 
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, BeforeValidator, ConfigDict, Field
 from web3 import Web3
 from web3.constants import ADDRESS_ZERO
 
@@ -50,6 +51,17 @@ class CreateCategoricalMarketsParams(BaseModel):
 SEER_BASE_URL = "https://app.seer.pm"
 
 
+def seer_normalize_wei(value: int | None) -> int | None:
+    # See https://github.com/seer-pm/demo/blob/main/web/netlify/edge-functions/utils/common.ts#L22
+    if value is None:
+        return value
+    is_in_wei = value > 1e10
+    return value if is_in_wei else value * 10**18
+
+
+SeerNormalizedWei = Annotated[Wei | None, BeforeValidator(seer_normalize_wei)]
+
+
 class SeerMarket(BaseModel):
     model_config = ConfigDict(populate_by_name=True)
 
@@ -70,6 +82,8 @@ class SeerMarket(BaseModel):
     payout_reported: bool = Field(alias="payoutReported")
     payout_numerators: list[int] = Field(alias="payoutNumerators")
     outcomes_supply: int = Field(alias="outcomesSupply")
+    upper_bound: SeerNormalizedWei = Field(alias="upperBound", default=None)
+    lower_bound: SeerNormalizedWei = Field(alias="lowerBound", default=None)
 
     @property
     def has_valid_answer(self) -> bool:

{prediction_market_agent_tooling-0.66.2 → prediction_market_agent_tooling-0.66.4}/prediction_market_agent_tooling/markets/seer/seer.py

@@ -32,6 +32,9 @@ from prediction_market_agent_tooling.markets.blockchain_utils import store_trade
 from prediction_market_agent_tooling.markets.data_models import ExistingPosition
 from prediction_market_agent_tooling.markets.market_fees import MarketFees
 from prediction_market_agent_tooling.markets.omen.omen import OmenAgentMarket
+from prediction_market_agent_tooling.markets.omen.omen_constants import (
+    SDAI_CONTRACT_ADDRESS,
+)
 from prediction_market_agent_tooling.markets.omen.omen_contracts import (
     SeerAgentResultMappingContract,
 )
@@ -62,6 +65,7 @@ from prediction_market_agent_tooling.tools.contract import (
     to_gnosis_chain_contract,
 )
 from prediction_market_agent_tooling.tools.cow.cow_order import (
+    NoLiquidityAvailableOnCowException,
     get_buy_token_amount_else_raise,
     get_orders_by_owner,
     get_trades_by_owner,
@@ -128,10 +132,41 @@ class SeerAgentMarket(AgentMarket):
         )
 
     def get_token_in_usd(self, x: CollateralToken) -> USD:
-        return get_token_in_usd(x, self.collateral_token_contract_address_checksummed)
+        try:
+            return get_token_in_usd(
+                x, self.collateral_token_contract_address_checksummed
+            )
+        except NoLiquidityAvailableOnCowException as e:
+            logger.warning(
+                f"Could not get quote for {self.collateral_token_contract_address_checksummed} from Cow, exception {e=}. Falling back to pools. "
+            )
+            token_price = self.get_colateral_price_from_pools()
+            if token_price is None:
+                raise RuntimeError(
+                    "Both CoW and pool-fallback way of getting price failed."
+                ) from e
+            return USD(x.value * token_price.value)
+
+    def get_colateral_price_from_pools(self) -> CollateralToken | None:
+        p = PriceManager.build(HexBytes(HexStr(self.id)))
+        token_price = p.get_token_price_from_pools(token=SDAI_CONTRACT_ADDRESS)
+        return token_price
 
     def get_usd_in_token(self, x: USD) -> CollateralToken:
-        return get_usd_in_token(x, self.collateral_token_contract_address_checksummed)
+        try:
+            return get_usd_in_token(
+                x, self.collateral_token_contract_address_checksummed
+            )
+        except NoLiquidityAvailableOnCowException as e:
+            logger.warning(
+                f"Could not get quote for {self.collateral_token_contract_address_checksummed} from Cow, exception {e=}. Falling back to pools. "
+            )
+            token_price = self.get_colateral_price_from_pools()
+            if not token_price:
+                raise RuntimeError(
+                    "Both CoW and pool-fallback way of getting price failed."
+                ) from e
+            return CollateralToken(x.value / token_price.value)
 
     def get_buy_token_amount(
         self, bet_amount: USD | CollateralToken, outcome_str: OutcomeStr
@@ -165,14 +200,26 @@ class SeerAgentMarket(AgentMarket):
             return CollateralToken.zero()
 
         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(
-            sell_amount=amount.as_outcome_wei.as_wei,
-            sell_token=wrapped_outcome_token,
-            buy_token=self.collateral_token_contract_address_checksummed,
-        )
-        return value_outcome_token_in_collateral.as_token
+        try:
+            # 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(
+                sell_amount=amount.as_outcome_wei.as_wei,
+                sell_token=wrapped_outcome_token,
+                buy_token=self.collateral_token_contract_address_checksummed,
+            )
+            return value_outcome_token_in_collateral.as_token
+        except NoLiquidityAvailableOnCowException as e:
+            logger.warning(
+                f"No liquidity available on Cow for {wrapped_outcome_token} -> {self.collateral_token_contract_address_checksummed}."
+            )
+            p = PriceManager.build(market_id=HexBytes(HexStr(self.id)))
+            price = p.get_token_price_from_pools(token=wrapped_outcome_token)
+            if not price:
+                logger.info(
+                    f"Could not get price for token from pools for {wrapped_outcome_token}"
+                )
+                raise e
+            return CollateralToken(price.value * amount.value)
 
     @staticmethod
     def get_trade_balance(api_keys: APIKeys) -> USD:
@@ -346,6 +393,8 @@ class SeerAgentMarket(AgentMarket):
             resolution=None,
             volume=None,
             probabilities=probability_map,
+            upper_bound=model.upper_bound,
+            lower_bound=model.lower_bound,
         )
 
         return market
@@ -358,6 +407,7 @@ class SeerAgentMarket(AgentMarket):
         created_after: t.Optional[DatetimeUTC] = None,
         excluded_questions: set[str] | None = None,
         fetch_categorical_markets: bool = False,
+        fetch_scalar_markets: bool = False,
     ) -> t.Sequence["SeerAgentMarket"]:
         seer_subgraph = SeerSubgraphHandler()
         markets = seer_subgraph.get_markets(
@@ -365,6 +415,8 @@ class SeerAgentMarket(AgentMarket):
             sort_by=sort_by,
             filter_by=filter_by,
             include_categorical_markets=fetch_categorical_markets,
+            include_only_scalar_markets=fetch_scalar_markets,
+            include_conditional_markets=False,
         )
 
         # We exclude the None values below because `from_data_model_with_subgraph` can return None, which
@@ -496,7 +548,11 @@ class SeerAgentMarket(AgentMarket):
             )
             return order_metadata.uid.root
 
-        except (UnexpectedResponseError, TimeoutError) as e:
+        except (
+            UnexpectedResponseError,
+            TimeoutError,
+            NoLiquidityAvailableOnCowException,
+        ) as e:
             # We don't retry if not enough balance.
             if "InsufficientBalance" in str(e):
                 raise e
@@ -506,6 +562,10 @@ class SeerAgentMarket(AgentMarket):
                 f"Exception occured when swapping tokens via Cowswap, doing swap via pools. {e}"
             )
 
+            if not self.has_liquidity():
+                logger.error(f"Market {self.id} has no liquidity. Cannot place bet.")
+                raise e
+
             tx_receipt = SwapPoolHandler(
                 api_keys=api_keys,
                 market_id=self.id,