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

prediction_market_agent_tooling/markets/polymarket/api.py

@@ -6,12 +6,14 @@ from urllib.parse import urljoin
 import httpx
 import tenacity
 
+from prediction_market_agent_tooling.gtypes import ChecksumAddress, HexBytes
 from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.markets.polymarket.data_models import (
     POLYMARKET_FALSE_OUTCOME,
     POLYMARKET_TRUE_OUTCOME,
     PolymarketGammaResponse,
     PolymarketGammaResponseDataItem,
+    PolymarketPositionResponse,
 )
 from prediction_market_agent_tooling.tools.datetime_utc import DatetimeUTC
 from prediction_market_agent_tooling.tools.httpx_cached_client import HttpxCachedClient
@@ -84,7 +86,7 @@ def get_polymarkets_with_pagination(
         markets_to_add = []
         for m in market_response.data:
             # Some Polymarket markets are missing the markets field
-            if m.markets is None:
+            if m.markets is None or m.markets[0].clobTokenIds is None:
                 continue
             if excluded_questions and m.title in excluded_questions:
                 continue
@@ -127,3 +129,35 @@ def get_polymarkets_with_pagination(
 
     # Return exactly the number of items requested (in case we got more due to batch size)
     return all_markets[:limit]
+
+
+@tenacity.retry(
+    stop=tenacity.stop_after_attempt(2),
+    wait=tenacity.wait_fixed(1),
+    after=lambda x: logger.debug(
+        f"get_user_positions failed, attempt={x.attempt_number}."
+    ),
+)
+def get_user_positions(
+    user_id: ChecksumAddress,
+    condition_ids: list[HexBytes] | None = None,
+) -> list[PolymarketPositionResponse]:
+    """Fetch a user's Polymarket positions; optionally filter by condition IDs."""
+    url = "https://data-api.polymarket.com/positions"
+    # ... rest of implementation ...
+    client: httpx.Client = HttpxCachedClient(ttl=timedelta(seconds=60)).get_client()
+
+    params = {
+        "user": user_id,
+        "market": ",".join([i.to_0x_hex() for i in condition_ids])
+        if condition_ids
+        else None,
+        "sortBy": "CASHPNL",  # Available options: TOKENS, CURRENT, INITIAL, CASHPNL, PERCENTPNL, TITLE, RESOLVING, PRICE
+    }
+    params = {k: v for k, v in params.items() if v is not None}
+
+    response = client.get(url, params=params)
+    response.raise_for_status()
+    data = response.json()
+    items = [PolymarketPositionResponse.model_validate(d) for d in data]
+    return items

prediction_market_agent_tooling/markets/polymarket/clob_manager.py

@@ -0,0 +1,156 @@
+from enum import Enum
+from typing import Dict
+
+from py_clob_client.client import ClobClient
+from py_clob_client.clob_types import MarketOrderArgs, OrderType
+from py_clob_client.order_builder.constants import BUY, SELL
+from pydantic import BaseModel
+from web3 import Web3
+
+from prediction_market_agent_tooling.chains import POLYGON_CHAIN_ID
+from prediction_market_agent_tooling.config import APIKeys, RPCConfig
+from prediction_market_agent_tooling.gtypes import USD, HexBytes, OutcomeToken, Wei
+from prediction_market_agent_tooling.loggers import logger
+from prediction_market_agent_tooling.markets.polymarket.constants import (
+    CTF_EXCHANGE_POLYMARKET,
+    NEG_RISK_ADAPTER,
+    NEG_RISK_EXCHANGE,
+    POLYMARKET_TINY_BET_AMOUNT,
+)
+from prediction_market_agent_tooling.markets.polymarket.polymarket_contracts import (
+    PolymarketConditionalTokenContract,
+    USDCeContract,
+)
+from prediction_market_agent_tooling.tools.cow.cow_order import handle_allowance
+
+HOST = "https://clob.polymarket.com"
+
+
+class AllowanceResult(BaseModel):
+    balance: float
+    allowances: Dict[str, float]
+
+
+class PolymarketPriceSideEnum(str, Enum):
+    BUY = "BUY"
+    SELL = "SELL"
+
+
+class OrderStatusEnum(str, Enum):
+    MATCHED = "matched"
+    LIVE = "live"
+    DELAYED = "delayed"
+    UNMATCHED = "unmatched"
+
+
+class CreateOrderResult(BaseModel):
+    errorMsg: str
+    orderID: str
+    transactionsHashes: list[HexBytes]
+    status: OrderStatusEnum
+    success: bool
+
+
+class PriceResponse(BaseModel):
+    price: float
+
+
+class ClobManager:
+    def __init__(self, api_keys: APIKeys):
+        self.api_keys = api_keys
+        self.clob_client = ClobClient(
+            HOST,
+            key=api_keys.bet_from_private_key.get_secret_value(),
+            chain_id=POLYGON_CHAIN_ID,
+        )
+        self.clob_client.set_api_creds(self.clob_client.create_or_derive_api_creds())
+        self.polygon_web3 = RPCConfig().get_polygon_web3()
+        self.__init_approvals(polygon_web3=self.polygon_web3)
+
+    def get_token_price(self, token_id: int, side: PolymarketPriceSideEnum) -> USD:
+        price_data = self.clob_client.get_price(token_id=token_id, side=side.value)
+        price_item = PriceResponse.model_validate(price_data)
+        return USD(price_item.price)
+
+    def _place_market_order(
+        self, token_id: int, amount: float, side: PolymarketPriceSideEnum
+    ) -> CreateOrderResult:
+        """Internal method to place a market order.
+
+        Args:
+            token_id: The token ID to trade
+            amount: The amount to trade (USDC for BUY, token shares for SELL)
+            side: Either BUY or SELL
+
+        Returns:
+            CreateOrderResult: The result of the order placement
+
+        Raises:
+            ValueError: If usdc_amount is < 1.0 for BUY orders
+        """
+        if side == PolymarketPriceSideEnum.BUY and amount < 1.0:
+            raise ValueError(
+                f"usdc_amounts < 1.0 are not supported by Polymarket, got {amount}"
+            )
+
+        # We check allowances first
+        self.__init_approvals()
+
+        order_args = MarketOrderArgs(
+            token_id=str(token_id),
+            amount=amount,
+            side=side.value,
+        )
+
+        logger.info(f"Placing market order: {order_args}")
+        signed_order = self.clob_client.create_market_order(order_args)
+        resp = self.clob_client.post_order(signed_order, orderType=OrderType.FOK)
+        return CreateOrderResult.model_validate(resp)
+
+    def place_buy_market_order(
+        self, token_id: int, usdc_amount: USD
+    ) -> CreateOrderResult:
+        """Place a market buy order for the given token with the specified USDC amount."""
+        return self._place_market_order(token_id, usdc_amount.value, BUY)
+
+    def place_sell_market_order(
+        self, token_id: int, token_shares: OutcomeToken
+    ) -> CreateOrderResult:
+        """Place a market sell order for the given token with the specified number of shares."""
+        return self._place_market_order(token_id, token_shares.value, SELL)
+
+    def __init_approvals(
+        self,
+        polygon_web3: Web3 | None = None,
+    ) -> None:
+        # from https://github.com/Polymarket/agents/blob/main/agents/polymarket/polymarket.py#L341
+        polygon_web3 = polygon_web3 or self.polygon_web3
+
+        usdc = USDCeContract()
+
+        # When setting allowances on Polymarket, it's important to set a large amount, because
+        # every trade reduces the allowance by the amount of the trade.
+        large_amount_wei = Wei(int(100 * 1e6))  # 100 USDC in Wei
+        amount_to_check_wei = Wei(int(POLYMARKET_TINY_BET_AMOUNT.value * 1e6))
+        ctf = PolymarketConditionalTokenContract()
+
+        for target_address in [
+            CTF_EXCHANGE_POLYMARKET,
+            NEG_RISK_EXCHANGE,
+            NEG_RISK_ADAPTER,
+        ]:
+            logger.info(f"Checking allowances for {target_address}")
+            handle_allowance(
+                api_keys=self.api_keys,
+                sell_token=usdc.address,
+                for_address=target_address,
+                amount_to_check_wei=amount_to_check_wei,
+                amount_to_set_wei=large_amount_wei,
+                web3=polygon_web3,
+            )
+
+            ctf.approve_if_not_approved(
+                api_keys=self.api_keys,
+                for_address=target_address,
+                web3=polygon_web3,
+            )

prediction_market_agent_tooling/markets/polymarket/constants.py

@@ -0,0 +1,15 @@
+from web3 import Web3
+
+from prediction_market_agent_tooling.gtypes import USD
+
+CTF_EXCHANGE_POLYMARKET = Web3.to_checksum_address(
+    "0x4bfb41d5b3570defd03c39a9a4d8de6bd8b8982e"
+)
+NEG_RISK_EXCHANGE = Web3.to_checksum_address(
+    "0xC5d563A36AE78145C45a50134d48A1215220f80a"
+)
+NEG_RISK_ADAPTER = Web3.to_checksum_address(
+    "0xd91E80cF2E7be2e162c6513ceD06f1dD0dA35296"
+)
+# We reference this value in multiple files
+POLYMARKET_TINY_BET_AMOUNT = USD(1.0)

prediction_market_agent_tooling/markets/polymarket/data_models.py

@@ -4,14 +4,14 @@ from pydantic import BaseModel
 
 from prediction_market_agent_tooling.gtypes import USDC, OutcomeStr, Probability
 from prediction_market_agent_tooling.markets.data_models import Resolution
-from prediction_market_agent_tooling.markets.polymarket.data_models_web import (
-    POLYMARKET_FALSE_OUTCOME,
-    POLYMARKET_TRUE_OUTCOME,
-    construct_polymarket_url,
-)
 from prediction_market_agent_tooling.tools.hexbytes_custom import HexBytes
 from prediction_market_agent_tooling.tools.utils import DatetimeUTC
 
+POLYMARKET_TRUE_OUTCOME = "Yes"
+POLYMARKET_FALSE_OUTCOME = "No"
+
+POLYMARKET_BASE_URL = "https://polymarket.com"
+
 
 class PolymarketRewards(BaseModel):
     min_size: int
@@ -39,6 +39,13 @@ class PolymarketGammaMarket(BaseModel):
     questionId: str | None = None
     clobTokenIds: str | None = None  # int-encoded hex
 
+    @property
+    def token_ids(self) -> list[int]:
+        # If market has no token_ids, we halt for safety since it will fail later on.
+        if not self.clobTokenIds:
+            raise ValueError("Market has no token_ids")
+        return [int(i) for i in json.loads(self.clobTokenIds)]
+
     @property
     def outcomes_list(self) -> list[OutcomeStr]:
         return [OutcomeStr(i) for i in json.loads(self.outcomes)]
@@ -186,3 +193,24 @@ class PolymarketMarketWithPrices(PolymarketMarket):
         raise ValueError(
             "Should not happen, as we filter only for binary markets in get_polymarket_binary_markets."
         )
+
+
+class PolymarketPositionResponse(BaseModel):
+    slug: str
+    eventSlug: str
+    proxyWallet: str
+    asset: str
+    conditionId: str
+    size: float
+    currentValue: float
+    cashPnl: float
+    redeemable: bool
+    outcome: str
+    outcomeIndex: int
+
+
+def construct_polymarket_url(slug: str) -> str:
+    """
+    Note: This works only if it's a single main market, not sub-market of some more general question.
+    """
+    return f"{POLYMARKET_BASE_URL}/event/{slug}"

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
+            )