prediction-market-agent-tooling 0.68.1__tar.gz → 0.69.1__tar.gz

{prediction_market_agent_tooling-0.68.1 → prediction_market_agent_tooling-0.69.1}/PKG-INFO

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

{prediction_market_agent_tooling-0.68.1 → prediction_market_agent_tooling-0.69.1}/prediction_market_agent_tooling/deploy/agent.py

@@ -630,7 +630,7 @@ class DeployableTraderAgent(DeployablePredictionAgent):
         api_keys = APIKeys()
 
         # Get the strategy to know how much it will bet.
-        strategy = self.get_betting_strategy(market)
+        strategy = self.get_betting_strategy_supported(market)
         # Have a little bandwidth after the bet.
         min_required_balance_to_trade = strategy.maximum_possible_bet_amount * 1.01
 
@@ -658,13 +658,24 @@ class DeployableTraderAgent(DeployablePredictionAgent):
         total_amount = self.get_total_amount_to_bet(market)
         return CategoricalMaxAccuracyBettingStrategy(max_position_amount=total_amount)
 
+    def get_betting_strategy_supported(self, market: AgentMarket) -> BettingStrategy:
+        """
+        Use this class internally to assert that the configured betting strategy works with the given market.
+        """
+        strategy = self.get_betting_strategy(market=market)
+        if not strategy.is_market_supported(market):
+            raise ValueError(
+                f"Market {market.url} is not supported by the strategy {strategy}."
+            )
+        return strategy
+
     def build_trades(
         self,
         market: AgentMarket,
         answer: CategoricalProbabilisticAnswer,
         existing_position: ExistingPosition | None,
     ) -> list[Trade]:
-        strategy = self.get_betting_strategy(market=market)
+        strategy = self.get_betting_strategy_supported(market=market)
         trades = strategy.calculate_trades(existing_position, answer, market)
         return trades
 

{prediction_market_agent_tooling-0.68.1 → prediction_market_agent_tooling-0.69.1}/prediction_market_agent_tooling/deploy/betting_strategy.py

@@ -16,7 +16,11 @@ from prediction_market_agent_tooling.gtypes import (
     Probability,
 )
 from prediction_market_agent_tooling.loggers import logger
-from prediction_market_agent_tooling.markets.agent_market import AgentMarket, MarketFees
+from prediction_market_agent_tooling.markets.agent_market import (
+    AgentMarket,
+    MarketFees,
+    QuestionType,
+)
 from prediction_market_agent_tooling.markets.data_models import (
     CategoricalProbabilisticAnswer,
     ExistingPosition,
@@ -24,10 +28,12 @@ from prediction_market_agent_tooling.markets.data_models import (
     Trade,
     TradeType,
 )
+from prediction_market_agent_tooling.markets.markets import MarketType
 from prediction_market_agent_tooling.markets.omen.omen import (
     get_buy_outcome_token_amount,
 )
 from prediction_market_agent_tooling.tools.betting_strategies.kelly_criterion import (
+    KellyType,
     get_kelly_bet_full,
     get_kelly_bet_simplified,
     get_kelly_bets_categorical_full,
@@ -45,9 +51,21 @@ class GuaranteedLossError(RuntimeError):
 
 
 class BettingStrategy(ABC):
+    supported_question_types: set[QuestionType]
+    supported_market_types: set[MarketType]
+
     def __init__(self, take_profit: bool = True) -> None:
         self.take_profit = take_profit
 
+    def is_market_supported(self, market: AgentMarket) -> bool:
+        if market.question_type not in self.supported_question_types:
+            return False
+
+        if MarketType.from_market(market) not in self.supported_market_types:
+            return False
+
+        return True
+
     @abstractmethod
     def calculate_trades(
         self,
@@ -251,6 +269,13 @@ class BettingStrategy(ABC):
 
 
 class CategoricalMaxAccuracyBettingStrategy(BettingStrategy):
+    supported_question_types = {
+        QuestionType.BINARY,
+        QuestionType.CATEGORICAL,
+        QuestionType.SCALAR,
+    }
+    supported_market_types = {x for x in MarketType if x.is_trading_market}
+
     def __init__(self, max_position_amount: USD, take_profit: bool = True):
         super().__init__(take_profit=take_profit)
         self.max_position_amount = max_position_amount
@@ -362,18 +387,20 @@ class MaxExpectedValueBettingStrategy(CategoricalMaxAccuracyBettingStrategy):
         return f"MaxExpectedValueBettingStrategy(max_position_amount={self.max_position_amount}, take_profit={self.take_profit})"
 
 
-class BinaryKellyBettingStrategy(BettingStrategy):
+class _BinaryKellyBettingStrategy(BettingStrategy):
+    supported_question_types = {QuestionType.BINARY}
+
     def __init__(
         self,
+        kelly_type: KellyType,
         max_position_amount: USD,
         max_price_impact: float | None = None,
         take_profit: bool = True,
-        force_simplified_calculation: bool = False,
     ):
         super().__init__(take_profit=take_profit)
+        self.kelly_type = kelly_type
         self.max_position_amount = max_position_amount
         self.max_price_impact = max_price_impact
-        self.force_simplified_calculation = force_simplified_calculation
 
     @property
     def maximum_possible_bet_amount(self) -> USD:
@@ -396,7 +423,7 @@ class BinaryKellyBettingStrategy(BettingStrategy):
             else override_p_yes
         )
 
-        if market.outcome_token_pool is None or self.force_simplified_calculation:
+        if self.kelly_type == KellyType.SIMPLE:
             kelly_bet = get_kelly_bet_simplified(
                 max_bet=market.get_usd_in_token(self.max_position_amount),
                 market_p_yes=market.probability_for_market_outcome(direction),
@@ -447,7 +474,6 @@ class BinaryKellyBettingStrategy(BettingStrategy):
             # Adjust amount
             max_price_impact_bet_amount = self.calculate_bet_amount_for_price_impact(
                 market,
-                kelly_bet.size,
                 direction=direction,
                 max_price_impact=self.max_price_impact,
             )
@@ -492,7 +518,6 @@ class BinaryKellyBettingStrategy(BettingStrategy):
     @staticmethod
     def calculate_bet_amount_for_price_impact(
         market: AgentMarket,
-        kelly_bet_size: CollateralToken,
         direction: OutcomeStr,
         max_price_impact: float,
     ) -> CollateralToken:
@@ -501,7 +526,7 @@ class BinaryKellyBettingStrategy(BettingStrategy):
         ) -> float:
             outcome_idx = market.get_outcome_index(direction)
             price_impact = (
-                BinaryKellyBettingStrategy.calculate_price_impact_for_bet_amount(
+                _BinaryKellyBettingStrategy.calculate_price_impact_for_bet_amount(
                     outcome_idx=outcome_idx,
                     bet_amount=CollateralToken(bet_amount_collateral),
                     pool_balances=pool_balances,
@@ -512,20 +537,13 @@ class BinaryKellyBettingStrategy(BettingStrategy):
             return abs(price_impact - max_price_impact)
 
         if not market.outcome_token_pool:
-            logger.warning(
+            raise ValueError(
                 "Market outcome_token_pool is None, cannot calculate bet amount"
             )
-            return kelly_bet_size
-
-        filtered_pool = {
-            outcome: pool_value
-            for outcome, pool_value in market.outcome_token_pool.items()
-            if INVALID_OUTCOME_LOWERCASE_IDENTIFIER not in outcome.lower()
-        }
 
-        pool_balances = [i.as_outcome_wei for i in filtered_pool.values()]
+        pool_balances = [i.as_outcome_wei for i in market.outcome_token_pool.values()]
         # stay float for compatibility with `minimize_scalar`
-        total_pool_balance = sum([i.value for i in filtered_pool.values()])
+        total_pool_balance = sum([i.value for i in market.outcome_token_pool.values()])
 
         # The bounds below have been found to work heuristically.
         optimized_bet_amount = minimize_scalar(
@@ -538,10 +556,47 @@ class BinaryKellyBettingStrategy(BettingStrategy):
         return CollateralToken(optimized_bet_amount.x)
 
     def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(max_position_amount={self.max_position_amount}, max_price_impact={self.max_price_impact}, take_profit={self.take_profit}, force_simplified_calculation={self.force_simplified_calculation})"
+        return f"{self.__class__.__name__}(max_position_amount={self.max_position_amount}, max_price_impact={self.max_price_impact}, take_profit={self.take_profit})"
+
+
+class SimpleBinaryKellyBettingStrategy(_BinaryKellyBettingStrategy):
+    supported_market_types = {x for x in MarketType if x.is_trading_market}
+
+    def __init__(
+        self,
+        max_position_amount: USD,
+        take_profit: bool = True,
+    ):
+        super().__init__(
+            kelly_type=KellyType.SIMPLE,
+            max_position_amount=max_position_amount,
+            max_price_impact=None,
+            take_profit=take_profit,
+        )
+
+
+class FullBinaryKellyBettingStrategy(_BinaryKellyBettingStrategy):
+    # Supports only OMEN because it uses closed-form formula derived from a binary FPMM.
+    supported_market_types = {MarketType.OMEN}
+
+    def __init__(
+        self,
+        max_position_amount: USD,
+        max_price_impact: float | None = None,
+        take_profit: bool = True,
+    ):
+        super().__init__(
+            kelly_type=KellyType.FULL,
+            max_position_amount=max_position_amount,
+            max_price_impact=max_price_impact,
+            take_profit=take_profit,
+        )
 
 
 class MaxAccuracyWithKellyScaledBetsStrategy(BettingStrategy):
+    supported_question_types = {QuestionType.BINARY}
+    supported_market_types = {MarketType.OMEN}
+
     def __init__(
         self,
         max_position_amount: USD,
@@ -573,7 +628,7 @@ class MaxAccuracyWithKellyScaledBetsStrategy(BettingStrategy):
         # We ignore the direction nudge given by Kelly, hence we assume we have a perfect prediction.
         estimated_p_yes = 1.0
 
-        kelly_bet = BinaryKellyBettingStrategy(
+        kelly_bet = FullBinaryKellyBettingStrategy(
             max_position_amount=self.max_position_amount
         ).get_kelly_bet(
             market=market,
@@ -601,24 +656,27 @@ class MaxAccuracyWithKellyScaledBetsStrategy(BettingStrategy):
         return f"{self.__class__.__name__}(max_position_amount={self.max_position_amount}, take_profit={self.take_profit})"
 
 
-class CategoricalKellyBettingStrategy(BettingStrategy):
+class _CategoricalKellyBettingStrategy(BettingStrategy):
+    supported_question_types = {QuestionType.BINARY, QuestionType.CATEGORICAL}
+    supported_market_types = {x for x in MarketType if x.is_trading_market}
+
     def __init__(
         self,
+        kelly_type: KellyType,
         max_position_amount: USD,
         max_price_impact: float | None,
         allow_multiple_bets: bool,
         allow_shorting: bool,
         multicategorical: bool,
         take_profit: bool = True,
-        force_simplified_calculation: bool = False,
     ):
         super().__init__(take_profit=take_profit)
+        self.kelly_type = kelly_type
         self.max_position_amount = max_position_amount
         self.max_price_impact = max_price_impact
         self.allow_multiple_bets = allow_multiple_bets
         self.allow_shorting = allow_shorting
         self.multicategorical = multicategorical
-        self.force_simplified_calculation = force_simplified_calculation
 
     @property
     def maximum_possible_bet_amount(self) -> USD:
@@ -632,7 +690,7 @@ class CategoricalKellyBettingStrategy(BettingStrategy):
     ) -> list[CategoricalKellyBet]:
         max_bet = market.get_usd_in_token(max_bet_amount)
 
-        if market.outcome_token_pool is None or self.force_simplified_calculation:
+        if self.kelly_type == KellyType.SIMPLE:
             kelly_bets = get_kelly_bets_categorical_simplified(
                 market_probabilities=[market.probabilities[o] for o in market.outcomes],
                 estimated_probabilities=[
@@ -647,8 +705,8 @@ class CategoricalKellyBettingStrategy(BettingStrategy):
 
         else:
             kelly_bets = get_kelly_bets_categorical_full(
-                outcome_pool_sizes=[
-                    market.outcome_token_pool[o] for o in market.outcomes
+                market_probabilities=[
+                    market.probability_for_market_outcome(o) for o in market.outcomes
                 ],
                 estimated_probabilities=[
                     answer.probability_for_market_outcome(o) for o in market.outcomes
@@ -659,6 +717,11 @@ class CategoricalKellyBettingStrategy(BettingStrategy):
                 allow_multiple_bets=self.allow_multiple_bets,
                 allow_shorting=self.allow_shorting,
                 multicategorical=self.multicategorical,
+                get_buy_token_amount=lambda bet_amount, outcome_index: check_not_none(
+                    market.get_buy_token_amount(
+                        bet_amount, market.get_outcome_str(outcome_index)
+                    )
+                ),
             )
 
         return kelly_bets
@@ -689,9 +752,8 @@ class CategoricalKellyBettingStrategy(BettingStrategy):
         if self.max_price_impact:
             # Adjust amount
             max_price_impact_bet_amount = (
-                BinaryKellyBettingStrategy.calculate_bet_amount_for_price_impact(
+                _BinaryKellyBettingStrategy.calculate_bet_amount_for_price_impact(
                     market,
-                    best_kelly_bet.size,
                     direction=market.get_outcome_str(best_kelly_bet.index),
                     max_price_impact=self.max_price_impact,
                 )
@@ -712,4 +774,45 @@ class CategoricalKellyBettingStrategy(BettingStrategy):
         return trades
 
     def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(max_position_amount={self.max_position_amount}, max_price_impact={self.max_price_impact}, allow_multiple_bets={self.allow_multiple_bets}, allow_shorting={self.allow_shorting}, take_profit={self.take_profit}, force_simplified_calculation={self.force_simplified_calculation})"
+        return f"{self.__class__.__name__}(max_position_amount={self.max_position_amount}, max_price_impact={self.max_price_impact}, allow_multiple_bets={self.allow_multiple_bets}, allow_shorting={self.allow_shorting}, take_profit={self.take_profit})"
+
+
+class SimpleCategoricalKellyBettingStrategy(_CategoricalKellyBettingStrategy):
+    def __init__(
+        self,
+        max_position_amount: USD,
+        allow_multiple_bets: bool,
+        allow_shorting: bool,
+        multicategorical: bool,
+        take_profit: bool = True,
+    ):
+        super().__init__(
+            kelly_type=KellyType.SIMPLE,
+            max_position_amount=max_position_amount,
+            max_price_impact=None,
+            allow_multiple_bets=allow_multiple_bets,
+            allow_shorting=allow_shorting,
+            multicategorical=multicategorical,
+            take_profit=take_profit,
+        )
+
+
+class FullCategoricalKellyBettingStrategy(_CategoricalKellyBettingStrategy):
+    def __init__(
+        self,
+        max_position_amount: USD,
+        max_price_impact: float | None,
+        allow_multiple_bets: bool,
+        allow_shorting: bool,
+        multicategorical: bool,
+        take_profit: bool = True,
+    ):
+        super().__init__(
+            kelly_type=KellyType.FULL,
+            max_position_amount=max_position_amount,
+            max_price_impact=max_price_impact,
+            allow_multiple_bets=allow_multiple_bets,
+            allow_shorting=allow_shorting,
+            multicategorical=multicategorical,
+            take_profit=take_profit,
+        )

{prediction_market_agent_tooling-0.68.1 → prediction_market_agent_tooling-0.69.1}/prediction_market_agent_tooling/jobs/omen/omen_jobs.py

@@ -1,10 +1,6 @@
 import typing as t
 
 from prediction_market_agent_tooling.config import APIKeys
-from prediction_market_agent_tooling.deploy.betting_strategy import (
-    BinaryKellyBettingStrategy,
-    TradeType,
-)
 from prediction_market_agent_tooling.gtypes import USD
 from prediction_market_agent_tooling.jobs.jobs_models import JobAgentMarket
 from prediction_market_agent_tooling.markets.agent_market import ProcessedMarket
@@ -92,20 +88,21 @@ class OmenJobAgentMarket(OmenAgentMarket, JobAgentMarket):
         return processed_traded_market
 
     def get_job_trade(self, max_bond: USD, result: str) -> Trade:
+        raise NotImplementedError("TODO: Refactor to avoid circular imports.")
         # Because jobs are powered by prediction markets, potentional reward depends on job's liquidity and our will to bond (bet) our xDai into our job completion.
-        strategy = BinaryKellyBettingStrategy(max_position_amount=max_bond)
-        required_trades = strategy.calculate_trades(
-            existing_position=None,
-            answer=self.get_job_answer(result),
-            market=self,
-        )
-        assert (
-            len(required_trades) == 1
-        ), f"Shouldn't process same job twice: {required_trades}"
-        trade = required_trades[0]
-        assert trade.trade_type == TradeType.BUY, "Should only buy on job markets."
-        assert trade.outcome, "Should buy only YES on job markets."
-        return required_trades[0]
+        # strategy = FullBinaryKellyBettingStrategy(max_position_amount=max_bond)
+        # required_trades = strategy.calculate_trades(
+        #     existing_position=None,
+        #     answer=self.get_job_answer(result),
+        #     market=self,
+        # )
+        # assert (
+        #     len(required_trades) == 1
+        # ), f"Shouldn't process same job twice: {required_trades}"
+        # trade = required_trades[0]
+        # assert trade.trade_type == TradeType.BUY, "Should only buy on job markets."
+        # assert trade.outcome, "Should buy only YES on job markets."
+        # return required_trades[0]
 
     @staticmethod
     def from_omen_market(market: OmenMarket) -> "OmenJobAgentMarket":

{prediction_market_agent_tooling-0.68.1 → prediction_market_agent_tooling-0.69.1}/prediction_market_agent_tooling/markets/agent_market.py

@@ -188,6 +188,17 @@ class AgentMarket(BaseModel):
             f"Could not find probability for market outcome {market_outcome}"
         )
 
+    @property
+    def question_type(self) -> QuestionType:
+        if self.is_binary:
+            return QuestionType.BINARY
+
+        elif self.is_scalar:
+            return QuestionType.SCALAR
+
+        else:
+            return QuestionType.CATEGORICAL
+
     @property
     def is_binary(self) -> bool:
         # 3 outcomes can also be binary if 3rd outcome is invalid (Seer)

{prediction_market_agent_tooling-0.68.1 → prediction_market_agent_tooling-0.69.1}/prediction_market_agent_tooling/markets/markets.py

@@ -31,6 +31,10 @@ class MarketType(str, Enum):
     METACULUS = "metaculus"
     SEER = "seer"
 
+    @staticmethod
+    def from_market(market: AgentMarket) -> "MarketType":
+        return AGENT_MARKET_TO_MARKET_TYPE[type(market)]
+
     @property
     def market_class(self) -> type[AgentMarket]:
         if self not in MARKET_TYPE_TO_AGENT_MARKET:
@@ -43,6 +47,15 @@ class MarketType(str, Enum):
             raise ValueError(f"Unknown market type: {self}")
         return JOB_MARKET_TYPE_TO_JOB_AGENT_MARKET[self]
 
+    @property
+    def is_trading_market(self) -> bool:
+        return self in [
+            MarketType.OMEN,
+            MarketType.POLYMARKET,
+            MarketType.SEER,
+            MarketType.MANIFOLD,
+        ]
+
     @property
     def is_blockchain_market(self) -> bool:
         return self in [MarketType.OMEN, MarketType.POLYMARKET, MarketType.SEER]
@@ -56,6 +69,9 @@ MARKET_TYPE_TO_AGENT_MARKET: dict[MarketType, type[AgentMarket]] = {
     MarketType.SEER: SeerAgentMarket,
 }
 
+AGENT_MARKET_TO_MARKET_TYPE: dict[type[AgentMarket], MarketType] = {
+    v: k for k, v in MARKET_TYPE_TO_AGENT_MARKET.items()
+}
 
 JOB_MARKET_TYPE_TO_JOB_AGENT_MARKET: dict[MarketType, type[JobAgentMarket]] = {
     MarketType.OMEN: OmenJobAgentMarket,

{prediction_market_agent_tooling-0.68.1 → prediction_market_agent_tooling-0.69.1}/prediction_market_agent_tooling/markets/seer/data_models.py

@@ -1,5 +1,6 @@
 import typing as t
 from datetime import timedelta
+from enum import Enum
 from typing import Annotated
 from urllib.parse import urljoin
 
@@ -139,11 +140,6 @@ class SeerMarket(BaseModel):
             for token in self.wrapped_tokens
         ]
 
-    @property
-    def is_binary(self) -> bool:
-        # 3 because Seer has also third, `Invalid` outcome.
-        return len(self.outcomes) == 3
-
     @property
     def collateral_token_contract_address_checksummed(self) -> ChecksumAddress:
         return Web3.to_checksum_address(self.collateral_token)
@@ -188,3 +184,42 @@ class ExactInputSingleParams(BaseModel):
     limit_sqrt_price: Wei = Field(
         alias="limitSqrtPrice", default_factory=lambda: Wei(0)
     )  # 0 for convenience, we also don't expect major price shifts
+
+
+class SeerTransactionType(str, Enum):
+    SWAP = "swap"
+    SPLIT = "split"
+
+
+class SeerTransaction(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    market_name: str = Field(alias="marketName")
+    market_id: HexBytes = Field(alias="marketId")
+    type: SeerTransactionType
+    block_number: int = Field(alias="blockNumber")
+    transaction_hash: HexBytes = Field(alias="transactionHash")
+    collateral: HexAddress
+    collateral_symbol: str = Field(alias="collateralSymbol")
+
+    token_in: HexAddress = Field(alias="tokenIn")
+    token_out: HexAddress = Field(alias="tokenOut")
+    amount_in: Wei = Field(alias="amountIn")
+    amount_out: Wei = Field(alias="amountOut")
+    token_in_symbol: str = Field(alias="tokenInSymbol")
+    token_out_symbol: str = Field(alias="tokenOutSymbol")
+    timestamp: int | None = None
+
+    amount: Wei | None = None
+
+    @property
+    def timestamp_dt(self) -> DatetimeUTC | None:
+        return DatetimeUTC.to_datetime_utc(self.timestamp) if self.timestamp else None
+
+    @property
+    def token_in_checksum(self) -> ChecksumAddress:
+        return Web3.to_checksum_address(self.token_in)
+
+    @property
+    def token_out_checksum(self) -> ChecksumAddress:
+        return Web3.to_checksum_address(self.token_out)

{prediction_market_agent_tooling-0.68.1 → prediction_market_agent_tooling-0.69.1}/prediction_market_agent_tooling/markets/seer/seer.py

@@ -35,6 +35,7 @@ from prediction_market_agent_tooling.markets.blockchain_utils import store_trade
 from prediction_market_agent_tooling.markets.data_models import (
     ExistingPosition,
     Resolution,
+    ResolvedBet,
 )
 from prediction_market_agent_tooling.markets.market_fees import MarketFees
 from prediction_market_agent_tooling.markets.omen.omen import (
@@ -56,6 +57,7 @@ from prediction_market_agent_tooling.markets.seer.exceptions import (
     PriceCalculationError,
 )
 from prediction_market_agent_tooling.markets.seer.price_manager import PriceManager
+from prediction_market_agent_tooling.markets.seer.seer_api import get_seer_transactions
 from prediction_market_agent_tooling.markets.seer.seer_contracts import (
     GnosisRouter,
     SeerMarketFactory,
@@ -81,7 +83,6 @@ from prediction_market_agent_tooling.tools.cow.cow_order import (
     OrderStatusError,
     get_orders_by_owner,
     get_trades_by_order_uid,
-    get_trades_by_owner,
     swap_tokens_waiting,
     wait_for_order_completion,
 )
@@ -272,10 +273,12 @@ class SeerAgentMarket(AgentMarket):
         """
         We filter the markets using previous trades by the user so that we don't have to process all Seer markets.
         """
-        trades_by_user = get_trades_by_owner(api_keys.bet_from_address)
+        trades_by_user = get_seer_transactions(
+            api_keys.bet_from_address, RPCConfig().CHAIN_ID
+        )
 
-        traded_tokens = {t.buyToken for t in trades_by_user}.union(
-            [t.sellToken for t in trades_by_user]
+        traded_tokens = {t.token_in_checksum for t in trades_by_user}.union(
+            [t.token_out_checksum for t in trades_by_user]
         )
         filtered_markets: list[SeerMarket] = []
         for market in markets:
@@ -313,19 +316,43 @@ class SeerAgentMarket(AgentMarket):
             for market in filtered_markets
             if market.is_redeemable(owner=api_keys.bet_from_address, web3=web3)
         ]
+        logger.info(f"Got {len(markets_to_redeem)} markets to redeem on Seer.")
 
         gnosis_router = GnosisRouter()
         for market in markets_to_redeem:
             try:
+                # GnosisRouter needs approval to use our outcome tokens
+                for i, token in enumerate(market.wrapped_tokens):
+                    ContractERC20OnGnosisChain(
+                        address=Web3.to_checksum_address(token)
+                    ).approve(
+                        api_keys,
+                        for_address=gnosis_router.address,
+                        amount_wei=market_balances[market.id][i].as_wei,
+                        web3=web3,
+                    )
+
+                # We can only ask for redeem of outcome tokens on correct outcomes
+                # TODO: Implement more complex use-cases: https://github.com/gnosis/prediction-market-agent-tooling/issues/850
+                amounts_to_redeem = [
+                    (amount if numerator > 0 else OutcomeWei(0))
+                    for amount, numerator in zip(
+                        market_balances[market.id], market.payout_numerators
+                    )
+                ]
+
+                # Redeem!
                 params = RedeemParams(
                     market=Web3.to_checksum_address(market.id),
                     outcome_indices=list(range(len(market.payout_numerators))),
-                    amounts=market_balances[market.id],
+                    amounts=amounts_to_redeem,
                 )
                 gnosis_router.redeem_to_base(api_keys, params=params, web3=web3)
-                logger.info(f"Redeemed market {market.id.to_0x_hex()}")
-            except Exception as e:
-                logger.error(f"Failed to redeem market {market.id.to_0x_hex()}, {e}")
+                logger.info(f"Redeemed market {market.url}.")
+            except Exception:
+                logger.exception(
+                    f"Failed to redeem market {market.url}, {market.outcomes}, with amounts {market_balances[market.id]} and payout numerators {market.payout_numerators}, and wrapped tokens {market.wrapped_tokens}."
+                )
 
         # GnosisRouter withdraws sDai into wxDAI/xDai on its own, so no auto-withdraw needed by us.
 
@@ -464,6 +491,15 @@ class SeerAgentMarket(AgentMarket):
 
         return market
 
+    @staticmethod
+    def get_resolved_bets_made_since(
+        better_address: ChecksumAddress,
+        start_time: DatetimeUTC,
+        end_time: DatetimeUTC | None,
+    ) -> list[ResolvedBet]:
+        # TODO: https://github.com/gnosis/prediction-market-agent-tooling/issues/841
+        raise NotImplementedError()
+
     @staticmethod
     def get_markets(
         limit: int,

prediction_market_agent_tooling-0.69.1/prediction_market_agent_tooling/markets/seer/seer_api.py

@@ -0,0 +1,28 @@
+import httpx
+
+from prediction_market_agent_tooling.gtypes import ChainID, ChecksumAddress
+from prediction_market_agent_tooling.markets.seer.data_models import SeerTransaction
+from prediction_market_agent_tooling.tools.datetime_utc import DatetimeUTC
+from prediction_market_agent_tooling.tools.utils import to_int_timestamp, utcnow
+
+
+def get_seer_transactions(
+    account: ChecksumAddress,
+    chain_id: ChainID,
+    start_time: DatetimeUTC | None = None,
+    end_time: DatetimeUTC | None = None,
+    timeout: int = 60,  # The endpoint is pretty slow to respond atm.
+) -> list[SeerTransaction]:
+    url = "https://app.seer.pm/.netlify/functions/get-transactions"
+    params: dict[str, str | int] = {
+        "account": account,
+        "chainId": chain_id,
+        "startTime": to_int_timestamp(start_time) if start_time else 0,
+        "endTime": to_int_timestamp(end_time if end_time else utcnow()),
+    }
+    response = httpx.get(url, params=params, timeout=timeout)
+    response.raise_for_status()
+    response_json = response.json()
+
+    transactions = [SeerTransaction.model_validate(tx) for tx in response_json]
+    return transactions