prediction-market-agent-tooling 0.68.0.dev999__py3-none-any.whl → 0.68.1__py3-none-any.whl

prediction_market_agent_tooling/markets/polymarket/polymarket.py

@@ -1,11 +1,19 @@
 import typing as t
 
+import cachetools
+from web3 import Web3
+
+from prediction_market_agent_tooling.config import APIKeys, RPCConfig
 from prediction_market_agent_tooling.gtypes import (
     USD,
+    ChecksumAddress,
     CollateralToken,
     HexBytes,
     OutcomeStr,
+    OutcomeToken,
     Probability,
+    Wei,
+    xDai,
 )
 from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.markets.agent_market import (
@@ -13,27 +21,45 @@ from prediction_market_agent_tooling.markets.agent_market import (
     ConditionalFilterType,
     FilterBy,
     MarketFees,
+    ProcessedMarket,
     QuestionType,
     SortBy,
 )
-from prediction_market_agent_tooling.markets.data_models import Resolution
+from prediction_market_agent_tooling.markets.data_models import (
+    ExistingPosition,
+    Resolution,
+)
 from prediction_market_agent_tooling.markets.polymarket.api import (
     PolymarketOrderByEnum,
     get_polymarkets_with_pagination,
+    get_user_positions,
+)
+from prediction_market_agent_tooling.markets.polymarket.clob_manager import (
+    ClobManager,
+    PolymarketPriceSideEnum,
+)
+from prediction_market_agent_tooling.markets.polymarket.constants import (
+    POLYMARKET_TINY_BET_AMOUNT,
 )
 from prediction_market_agent_tooling.markets.polymarket.data_models import (
+    POLYMARKET_BASE_URL,
     PolymarketGammaResponseDataItem,
 )
-from prediction_market_agent_tooling.markets.polymarket.data_models_web import (
-    POLYMARKET_BASE_URL,
+from prediction_market_agent_tooling.markets.polymarket.polymarket_contracts import (
+    USDCeContract,
 )
 from prediction_market_agent_tooling.markets.polymarket.polymarket_subgraph_handler import (
     ConditionSubgraphModel,
     PolymarketSubgraphHandler,
 )
 from prediction_market_agent_tooling.tools.datetime_utc import DatetimeUTC
+from prediction_market_agent_tooling.tools.tokens.usd import get_token_in_usd
 from prediction_market_agent_tooling.tools.utils import check_not_none
 
+SHARED_CACHE: cachetools.TTLCache[t.Hashable, t.Any] = cachetools.TTLCache(
+    maxsize=256, ttl=10 * 60
+)
+
 
 class PolymarketAgentMarket(AgentMarket):
     """
@@ -47,6 +73,15 @@ class PolymarketAgentMarket(AgentMarket):
     # But then in the new subgraph API, they have `fee: BigInt! (Percentage fee of trades taken by market maker. A 2% fee is represented as 2*10^16)`.
     # TODO: Check out the fees while integrating the subgraph API or if we implement placing of bets on Polymarket.
     fees: MarketFees = MarketFees.get_zero_fees()
+    condition_id: HexBytes
+    liquidity_usd: USD
+    token_ids: list[int]
+    closed_flag_from_polymarket: bool
+    active_flag_from_polymarket: bool
+
+    @staticmethod
+    def collateral_token_address() -> ChecksumAddress:
+        return USDCeContract().address
 
     @staticmethod
     def build_resolution_from_condition(
@@ -73,7 +108,7 @@ class PolymarketAgentMarket(AgentMarket):
         if len(payout_numerator_indices_gt_0) != 1:
             # These cases involve multi-categorical resolution (to be implemented https://github.com/gnosis/prediction-market-agent-tooling/issues/770)
             logger.warning(
-                f"Only binary markets are supported. Got payout numerators: {condition_model.payoutNumerators} for condition_id {condition_id.hex()}"
+                f"Only binary markets are supported. Got payout numerators: {condition_model.payoutNumerators} for condition_id {condition_id.to_0x_hex()}"
             )
             return Resolution(outcome=None, invalid=False)
 
@@ -81,42 +116,68 @@ class PolymarketAgentMarket(AgentMarket):
         resolved_outcome = outcomes[payout_numerator_indices_gt_0[0]]
         return Resolution.from_answer(resolved_outcome)
 
+    def get_token_id_for_outcome(self, outcome: OutcomeStr) -> int:
+        outcome_idx = self.outcomes.index(outcome)
+        return self.token_ids[outcome_idx]
+
     @staticmethod
     def from_data_model(
         model: PolymarketGammaResponseDataItem,
         condition_model_dict: dict[HexBytes, ConditionSubgraphModel],
-    ) -> "PolymarketAgentMarket":
+    ) -> t.Optional["PolymarketAgentMarket"]:
         # If len(model.markets) > 0, this denotes a categorical market.
         markets = check_not_none(model.markets)
         outcomes = markets[0].outcomes_list
         outcome_prices = markets[0].outcome_prices
         if not outcome_prices:
-            # We give random prices
-            outcome_prices = [0.5, 0.5]
+            logger.info(f"Market has no outcome prices. Skipping. {model=}")
+            return None
+
         probabilities = {o: Probability(op) for o, op in zip(outcomes, outcome_prices)}
 
+        condition_id = markets[0].conditionId
         resolution = PolymarketAgentMarket.build_resolution_from_condition(
-            condition_id=markets[0].conditionId,
+            condition_id=condition_id,
             condition_model_dict=condition_model_dict,
             outcomes=outcomes,
         )
 
         return PolymarketAgentMarket(
             id=model.id,
+            condition_id=condition_id,
             question=model.title,
             description=model.description,
             outcomes=outcomes,
             resolution=resolution,
             created_time=model.startDate,
             close_time=model.endDate,
+            closed_flag_from_polymarket=model.closed,
+            active_flag_from_polymarket=model.active,
             url=model.url,
             volume=CollateralToken(model.volume) if model.volume else None,
             outcome_token_pool=None,
             probabilities=probabilities,
+            liquidity_usd=USD(model.liquidity)
+            if model.liquidity is not None
+            else USD(0),
+            token_ids=markets[0].token_ids,
         )
 
     def get_tiny_bet_amount(self) -> CollateralToken:
-        raise NotImplementedError("TODO: Implement to allow betting on Polymarket.")
+        return CollateralToken(POLYMARKET_TINY_BET_AMOUNT.value)
+
+    def get_token_in_usd(self, x: CollateralToken) -> USD:
+        return get_token_in_usd(x, self.collateral_token_address())
+
+    @staticmethod
+    def get_trade_balance(api_keys: APIKeys, web3: Web3 | None = None) -> USD:
+        usdc_balance_wei = USDCeContract().balanceOf(
+            for_address=api_keys.public_key, web3=web3
+        )
+        return USD(usdc_balance_wei.value * 1e-6)
+
+    def get_liquidity(self, web3: Web3 | None = None) -> CollateralToken:
+        return CollateralToken(self.liquidity_usd.value)
 
     def place_bet(self, outcome: OutcomeStr, amount: USD) -> str:
         raise NotImplementedError("TODO: Implement to allow betting on Polymarket.")
@@ -146,6 +207,7 @@ class PolymarketAgentMarket(AgentMarket):
         match sort_by:
             case SortBy.NEWEST:
                 order_by = PolymarketOrderByEnum.START_DATE
+                ascending = False
             case SortBy.CLOSING_SOONEST:
                 ascending = True
                 order_by = PolymarketOrderByEnum.END_DATE
@@ -168,15 +230,182 @@ class PolymarketAgentMarket(AgentMarket):
         )
 
         condition_models = PolymarketSubgraphHandler().get_conditions(
-            condition_ids=[
-                market.markets[0].conditionId
-                for market in markets
-                if market.markets is not None
-            ]
+            condition_ids=list(
+                set(
+                    [
+                        market.markets[0].conditionId
+                        for market in markets
+                        if market.markets is not None
+                    ]
+                )
+            )
         )
         condition_models_dict = {c.id: c for c in condition_models}
 
-        return [
-            PolymarketAgentMarket.from_data_model(m, condition_models_dict)
-            for m in markets
-        ]
+        result_markets: list[PolymarketAgentMarket] = []
+        for m in markets:
+            market = PolymarketAgentMarket.from_data_model(m, condition_models_dict)
+            if market is not None:
+                result_markets.append(market)
+        return result_markets
+
+    def ensure_min_native_balance(
+        self,
+        min_required_balance: xDai,
+        multiplier: float = 3.0,
+        web3: Web3 | None = None,
+    ) -> None:
+        balance_collateral = USDCeContract().balanceOf(
+            for_address=APIKeys().public_key, web3=web3
+        )
+        # USDC has 6 decimals, xDAI has 18. We convert from Wei into atomic units.
+        balance_collateral_atomic = CollateralToken(float(balance_collateral) / 1e6)
+        if balance_collateral_atomic < min_required_balance.as_token:
+            raise EnvironmentError(
+                f"USDC balance {balance_collateral_atomic} < {min_required_balance.as_token=}"
+            )
+
+    @staticmethod
+    def redeem_winnings(api_keys: APIKeys) -> None:
+        # ToDo - implement me - https://github.com/gnosis/prediction-market-agent-tooling/issues/824
+        pass
+
+    @staticmethod
+    def verify_operational_balance(api_keys: APIKeys) -> bool:
+        """Method for checking if agent has enough funds to pay for gas fees."""
+        web3 = RPCConfig().get_polygon_web3()
+        pol_balance: Wei = Wei(web3.eth.get_balance(api_keys.public_key))
+        return pol_balance > Wei(int(0.001 * 1e18))
+
+    def store_prediction(
+        self,
+        processed_market: ProcessedMarket | None,
+        keys: APIKeys,
+        agent_name: str,
+    ) -> None:
+        pass
+
+    def store_trades(
+        self,
+        traded_market: ProcessedMarket | None,
+        keys: APIKeys,
+        agent_name: str,
+        web3: Web3 | None = None,
+    ) -> None:
+        logger.info("Storing trades deactivated for Polymarket.")
+        # Understand how market_id can be represented.
+        # Condition_id could work but length doesn't seem to match.
+
+    @classmethod
+    def get_user_url(cls, keys: APIKeys) -> str:
+        return f"https://polymarket.com/{keys.public_key}"
+
+    def get_position(
+        self, user_id: str, web3: Web3 | None = None
+    ) -> ExistingPosition | None:
+        """
+        Fetches position from the user in a given market.
+        """
+        positions = get_user_positions(
+            user_id=Web3.to_checksum_address(user_id), condition_ids=[self.condition_id]
+        )
+        if not positions:
+            return None
+
+        amounts_ot = {i: OutcomeToken(0) for i in self.outcomes}
+        amounts_potential = {i: USD(0) for i in self.outcomes}
+        amounts_current = {i: USD(0) for i in self.outcomes}
+
+        for p in positions:
+            if p.conditionId != self.condition_id.to_0x_hex():
+                continue
+
+            amounts_potential[OutcomeStr(p.outcome)] = USD(p.size)
+            amounts_ot[OutcomeStr(p.outcome)] = OutcomeToken(p.size)
+            amounts_current[OutcomeStr(p.outcome)] = USD(p.currentValue)
+
+        return ExistingPosition(
+            amounts_potential=amounts_potential,
+            amounts_ot=amounts_ot,
+            market_id=self.id,
+            amounts_current=amounts_current,
+        )
+
+    def can_be_traded(self) -> bool:
+        return (
+            self.active_flag_from_polymarket
+            and not self.closed_flag_from_polymarket
+            and self.liquidity_usd
+            > USD(5)  # we conservatively require some positive liquidity to trade on
+        )
+
+    def get_buy_token_amount(
+        self, bet_amount: USD | CollateralToken, outcome_str: OutcomeStr
+    ) -> OutcomeToken:
+        """Returns number of outcome tokens returned for a given bet expressed in collateral units."""
+
+        if outcome_str not in self.outcomes:
+            raise ValueError(
+                f"Outcome {outcome_str} not found in market outcomes {self.outcomes}"
+            )
+
+        token_id = self.get_token_id_for_outcome(outcome_str)
+
+        price = ClobManager(APIKeys()).get_token_price(
+            token_id=token_id, side=PolymarketPriceSideEnum.BUY
+        )
+        if not price:
+            raise ValueError(
+                f"Could not get price for outcome {outcome_str} with token_id {token_id}"
+            )
+
+        # we work with floats since USD and Collateral are the same on Polymarket
+        buy_token_amount = bet_amount.value / price.value
+        logger.info(f"Buy token amount: {buy_token_amount=}")
+        return OutcomeToken(buy_token_amount)
+
+    def buy_tokens(self, outcome: OutcomeStr, amount: USD) -> str:
+        clob_manager = ClobManager(APIKeys())
+        token_id = self.get_token_id_for_outcome(outcome)
+
+        created_order = clob_manager.place_buy_market_order(
+            token_id=token_id, usdc_amount=amount
+        )
+        if not created_order.success:
+            raise ValueError(f"Error creating order: {created_order}")
+
+        return created_order.transactionsHashes[0].to_0x_hex()
+
+    def sell_tokens(
+        self,
+        outcome: OutcomeStr,
+        amount: USD | OutcomeToken,
+        api_keys: APIKeys | None = None,
+    ) -> str:
+        """
+        Polymarket's API expect shares to be sold. 1 share == 1 outcome token / 1e6.
+        The number of outcome tokens matches the `balanceOf` of the conditionalTokens contract.
+        In comparison, the number of shares match the position.size from the user position.
+        """
+        logger.info(f"Selling {amount=} from {outcome=}")
+        clob_manager = ClobManager(api_keys=api_keys or APIKeys())
+        token_id = self.get_token_id_for_outcome(outcome)
+        token_shares: OutcomeToken
+        if isinstance(amount, OutcomeToken):
+            token_shares = amount
+        elif isinstance(amount, USD):
+            token_price = clob_manager.get_token_price(
+                token_id=token_id, side=PolymarketPriceSideEnum.SELL
+            )
+            # We expect that our order sizes don't move the price too much.
+            token_shares = OutcomeToken(amount.value / token_price.value)
+        else:
+            raise ValueError(f"Unsupported amount type {type(amount)}")
+
+        created_order = clob_manager.place_sell_market_order(
+            token_id=token_id, token_shares=token_shares
+        )
+        if not created_order.success:
+            raise ValueError(f"Error creating order: {created_order}")
+
+        return created_order.transactionsHashes[0].to_0x_hex()

prediction_market_agent_tooling/markets/polymarket/polymarket_contracts.py

@@ -0,0 +1,35 @@
+from web3 import Web3
+
+from prediction_market_agent_tooling.config import APIKeys
+from prediction_market_agent_tooling.gtypes import ChecksumAddress
+from prediction_market_agent_tooling.tools.contract import (
+    ConditionalTokenContract,
+    ContractERC20BaseClass,
+    ContractOnPolygonChain,
+)
+
+
+class USDCeContract(ContractERC20BaseClass, ContractOnPolygonChain):
+    # USDC.e is used by Polymarket.
+    address: ChecksumAddress = Web3.to_checksum_address(
+        "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174"
+    )
+
+
+class PolymarketConditionalTokenContract(
+    ConditionalTokenContract, ContractOnPolygonChain
+):
+    address: ChecksumAddress = Web3.to_checksum_address(
+        "0x4D97DCd97eC945f40cF65F87097ACe5EA0476045"
+    )
+
+    def approve_if_not_approved(
+        self, api_keys: APIKeys, for_address: ChecksumAddress, web3: Web3 | None = None
+    ) -> None:
+        is_approved = self.isApprovedForAll(
+            owner=api_keys.public_key, for_address=for_address, web3=web3
+        )
+        if not is_approved:
+            self.setApprovalForAll(
+                api_keys=api_keys, for_address=for_address, approve=True, web3=web3
+            )

prediction_market_agent_tooling/markets/polymarket/polymarket_subgraph_handler.py

@@ -30,8 +30,9 @@ class PolymarketSubgraphHandler(BaseSubgraphHandler):
     def get_conditions(
         self, condition_ids: list[HexBytes]
     ) -> list[ConditionSubgraphModel]:
-        where_stms = {"id_in": [i.hex() for i in condition_ids]}
+        where_stms = {"id_in": [i.to_0x_hex() for i in condition_ids]}
         conditions = self.conditions_subgraph.Query.conditions(
+            first=len(condition_ids),
             where=where_stms,
         )
 

prediction_market_agent_tooling/markets/seer/data_models.py

@@ -160,7 +160,7 @@ class SeerMarket(BaseModel):
     @property
     def url(self) -> str:
         chain_id = RPCConfig().chain_id
-        return urljoin(SEER_BASE_URL, f"markets/{chain_id}/{self.id.hex()}")
+        return urljoin(SEER_BASE_URL, f"markets/{chain_id}/{self.id.to_0x_hex()}")
 
 
 class SeerMarketWithQuestions(SeerMarket):

prediction_market_agent_tooling/markets/seer/price_manager.py

@@ -2,11 +2,15 @@ from cachetools import TTLCache, cached
 from pydantic import BaseModel
 from web3 import Web3
 
+from prediction_market_agent_tooling.deploy.constants import (
+    INVALID_OUTCOME_LOWERCASE_IDENTIFIER,
+)
 from prediction_market_agent_tooling.gtypes import (
     ChecksumAddress,
     CollateralToken,
     HexAddress,
     OutcomeStr,
+    OutcomeToken,
     Probability,
 )
 from prediction_market_agent_tooling.loggers import logger
@@ -46,7 +50,7 @@ class PriceManager:
         price_diff_pct = abs(old_price - normalized_price) / max(old_price, 0.01)
         if price_diff_pct > max_price_diff:
             logger.info(
-                f"{price_diff_pct=} larger than {max_price_diff=} for seer market {self.seer_market.id.hex()} "
+                f"{price_diff_pct=} larger than {max_price_diff=} for seer market {self.seer_market.id.to_0x_hex()} "
             )
 
     def get_price_for_token(self, token: ChecksumAddress) -> CollateralToken | None:
@@ -182,3 +186,67 @@ class PriceManager:
             normalized_prices[outcome] = new_price
 
         return normalized_prices
+
+    def build_initial_probs_from_pool(
+        self, model: SeerMarket, wrapped_tokens: list[ChecksumAddress]
+    ) -> tuple[dict[OutcomeStr, Probability], dict[OutcomeStr, OutcomeToken]]:
+        """
+        Builds a map of outcome to probability and outcome token pool.
+        """
+        probability_map = {}
+        outcome_token_pool = {}
+        wrapped_tokens_with_supply = [
+            (
+                token,
+                SeerSubgraphHandler().get_pool_by_token(
+                    token, model.collateral_token_contract_address_checksummed
+                ),
+            )
+            for token in wrapped_tokens
+        ]
+        wrapped_tokens_with_supply = [
+            (token, pool)
+            for token, pool in wrapped_tokens_with_supply
+            if pool is not None
+        ]
+
+        for token, pool in wrapped_tokens_with_supply:
+            if pool is None or pool.token1.id is None or pool.token0.id is None:
+                continue
+            if HexBytes(token) == HexBytes(pool.token1.id):
+                outcome_token_pool[
+                    OutcomeStr(model.outcomes[wrapped_tokens.index(token)])
+                ] = (
+                    OutcomeToken(pool.totalValueLockedToken0)
+                    if pool.totalValueLockedToken0 is not None
+                    else OutcomeToken(0)
+                )
+                probability_map[
+                    OutcomeStr(model.outcomes[wrapped_tokens.index(token)])
+                ] = Probability(pool.token0Price.value)
+            else:
+                outcome_token_pool[
+                    OutcomeStr(model.outcomes[wrapped_tokens.index(token)])
+                ] = (
+                    OutcomeToken(pool.totalValueLockedToken1)
+                    if pool.totalValueLockedToken1 is not None
+                    else OutcomeToken(0)
+                )
+                probability_map[
+                    OutcomeStr(model.outcomes[wrapped_tokens.index(token)])
+                ] = Probability(pool.token1Price.value)
+
+        for outcome in model.outcomes:
+            if outcome not in outcome_token_pool:
+                outcome_token_pool[outcome] = OutcomeToken(0)
+                logger.warning(
+                    f"Outcome {outcome} not found in outcome_token_pool for market {self.seer_market.url}."
+                )
+            if outcome not in probability_map:
+                if INVALID_OUTCOME_LOWERCASE_IDENTIFIER not in outcome.lower():
+                    raise PriceCalculationError(
+                        f"Couldn't get probability for {outcome} for market {self.seer_market.url}."
+                    )
+                else:
+                    probability_map[outcome] = Probability(0)
+        return probability_map, outcome_token_pool

prediction_market_agent_tooling/markets/seer/seer.py

@@ -28,7 +28,6 @@ from prediction_market_agent_tooling.markets.agent_market import (
     FilterBy,
     ParentMarket,
     ProcessedMarket,
-    ProcessedTradedMarket,
     QuestionType,
     SortBy,
 )
@@ -38,7 +37,10 @@ from prediction_market_agent_tooling.markets.data_models import (
     Resolution,
 )
 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 import (
+    OmenAgentMarket,
+    send_keeping_token_to_eoa_xdai,
+)
 from prediction_market_agent_tooling.markets.omen.omen_constants import (
     SDAI_CONTRACT_ADDRESS,
 )
@@ -136,7 +138,7 @@ class SeerAgentMarket(AgentMarket):
 
     def store_trades(
         self,
-        traded_market: ProcessedTradedMarket | None,
+        traded_market: ProcessedMarket | None,
         keys: APIKeys,
         agent_name: str,
         web3: Web3 | None = None,
@@ -262,10 +264,6 @@ class SeerAgentMarket(AgentMarket):
             amounts_ot=amounts_ot,
         )
 
-    @staticmethod
-    def get_user_id(api_keys: APIKeys) -> str:
-        return OmenAgentMarket.get_user_id(api_keys)
-
     @staticmethod
     def _filter_markets_contained_in_trades(
         api_keys: APIKeys,
@@ -325,9 +323,9 @@ class SeerAgentMarket(AgentMarket):
                     amounts=market_balances[market.id],
                 )
                 gnosis_router.redeem_to_base(api_keys, params=params, web3=web3)
-                logger.info(f"Redeemed market {market.id.hex()}")
+                logger.info(f"Redeemed market {market.id.to_0x_hex()}")
             except Exception as e:
-                logger.error(f"Failed to redeem market {market.id.hex()}, {e}")
+                logger.error(f"Failed to redeem market {market.id.to_0x_hex()}, {e}")
 
         # GnosisRouter withdraws sDai into wxDAI/xDai on its own, so no auto-withdraw needed by us.
 
@@ -345,6 +343,17 @@ class SeerAgentMarket(AgentMarket):
 
         return False
 
+    def ensure_min_native_balance(
+        self,
+        min_required_balance: xDai,
+        multiplier: float = 3.0,
+    ) -> None:
+        send_keeping_token_to_eoa_xdai(
+            api_keys=APIKeys(),
+            min_required_balance=min_required_balance,
+            multiplier=multiplier,
+        )
+
     @staticmethod
     def verify_operational_balance(api_keys: APIKeys) -> bool:
         return OmenAgentMarket.verify_operational_balance(api_keys=api_keys)
@@ -367,7 +376,7 @@ class SeerAgentMarket(AgentMarket):
             raise ValueError("Seer categorical markets must have 1 question.")
 
         question = model.questions[0]
-        outcome = model.outcomes[int(question.question.best_answer.hex(), 16)]
+        outcome = model.outcomes[int(question.question.best_answer.to_0x_hex(), 16)]
         return Resolution(outcome=outcome, invalid=False)
 
     @staticmethod
@@ -411,13 +420,17 @@ class SeerAgentMarket(AgentMarket):
         must_have_prices: bool,
     ) -> t.Optional["SeerAgentMarket"]:
         price_manager = PriceManager(seer_market=model, seer_subgraph=seer_subgraph)
-
-        probability_map = {}
+        wrapped_tokens = [Web3.to_checksum_address(i) for i in model.wrapped_tokens]
         try:
-            probability_map = price_manager.build_probability_map()
+            (
+                probability_map,
+                outcome_token_pool,
+            ) = price_manager.build_initial_probs_from_pool(
+                model=model, wrapped_tokens=wrapped_tokens
+            )
         except PriceCalculationError as e:
             logger.info(
-                f"Error when calculating probabilities for market {model.id.hex()} - {e}"
+                f"Error when calculating probabilities for market {model.id.to_0x_hex()} - {e}"
             )
             if must_have_prices:
                 # Price calculation failed, so don't return the market
@@ -428,7 +441,7 @@ class SeerAgentMarket(AgentMarket):
         parent = SeerAgentMarket.get_parent(model=model, seer_subgraph=seer_subgraph)
 
         market = SeerAgentMarket(
-            id=model.id.hex(),
+            id=model.id.to_0x_hex(),
             question=model.title,
             creator=model.creator,
             created_time=model.created_time,
@@ -437,9 +450,9 @@ class SeerAgentMarket(AgentMarket):
             condition_id=model.condition_id,
             url=model.url,
             close_time=model.close_time,
-            wrapped_tokens=[Web3.to_checksum_address(i) for i in model.wrapped_tokens],
+            wrapped_tokens=wrapped_tokens,
             fees=MarketFees.get_zero_fees(),
-            outcome_token_pool=None,
+            outcome_token_pool=outcome_token_pool,
             outcomes_supply=model.outcomes_supply,
             resolution=resolution,
             volume=None,
@@ -521,7 +534,9 @@ class SeerAgentMarket(AgentMarket):
             )
 
             token_balance = token_contract.balance_of_in_tokens(
-                for_address=Web3.to_checksum_address(HexAddress(HexStr(pool.id.hex()))),
+                for_address=Web3.to_checksum_address(
+                    HexAddress(HexStr(pool.id.to_0x_hex()))
+                ),
                 web3=web3,
             )
             collateral_balance = p.get_amount_of_token_in_collateral(
@@ -602,7 +617,7 @@ class SeerAgentMarket(AgentMarket):
                 )
             cow_tx_hash = trades[0].txHash
             logger.info(f"TxHash is {cow_tx_hash=} for {order_metadata.uid.root=}.")
-            return cow_tx_hash.hex()
+            return cow_tx_hash.to_0x_hex()
 
         except (
             UnexpectedResponseError,
@@ -635,7 +650,7 @@ class SeerAgentMarket(AgentMarket):
             )
             swap_pool_tx_hash = tx_receipt["transactionHash"]
             logger.info(f"TxHash is {swap_pool_tx_hash=}.")
-            return swap_pool_tx_hash.hex()
+            return swap_pool_tx_hash.to_0x_hex()
 
     def place_bet(
         self,