prediction-market-agent-tooling 0.65.5__py3-none-any.whl → 0.69.17.dev1149__py3-none-any.whl

prediction_market_agent_tooling/markets/polymarket/api.py

@@ -1,140 +1,163 @@
 import typing as t
+from datetime import timedelta
+from enum import Enum
+from urllib.parse import urljoin
 
-import requests
+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,
-    MarketsEndpointResponse,
-    PolymarketMarket,
-    PolymarketMarketWithPrices,
-    PolymarketPriceResponse,
-    PolymarketTokenWithPrices,
-    Prices,
+    PolymarketGammaResponse,
+    PolymarketGammaResponseDataItem,
+    PolymarketPositionResponse,
 )
+from prediction_market_agent_tooling.tools.datetime_utc import DatetimeUTC
+from prediction_market_agent_tooling.tools.httpx_cached_client import HttpxCachedClient
 from prediction_market_agent_tooling.tools.utils import response_to_model
 
-POLYMARKET_API_BASE_URL = "https://clob.polymarket.com/"
 MARKETS_LIMIT = 100  # Polymarket will only return up to 100 markets
+POLYMARKET_GAMMA_API_BASE_URL = "https://gamma-api.polymarket.com/"
 
 
-@tenacity.retry(
-    stop=tenacity.stop_after_attempt(5),
-    wait=tenacity.wait_chain(*[tenacity.wait_fixed(n) for n in range(1, 6)]),
-    after=lambda x: logger.debug(f"get_polymarkets failed, {x.attempt_number=}."),
-)
-def get_polymarkets(
-    limit: int,
-    with_rewards: bool = False,
-    next_cursor: str | None = None,
-) -> MarketsEndpointResponse:
-    url = (
-        f"{POLYMARKET_API_BASE_URL}/{'sampling-markets' if with_rewards else 'markets'}"
-    )
-    params: dict[str, str | int | float | None] = {
-        "limit": min(limit, MARKETS_LIMIT),
-    }
-    if next_cursor is not None:
-        params["next_cursor"] = next_cursor
-    return response_to_model(requests.get(url, params=params), MarketsEndpointResponse)
+class PolymarketOrderByEnum(str, Enum):
+    LIQUIDITY = "liquidity"
+    START_DATE = "startDate"
+    END_DATE = "endDate"
+    VOLUME_24HR = "volume24hr"
 
 
-def get_polymarket_binary_markets(
+@tenacity.retry(
+    stop=tenacity.stop_after_attempt(2),
+    wait=tenacity.wait_fixed(1),
+    after=lambda x: logger.debug(
+        f"get_polymarkets_with_pagination failed, {x.attempt_number=}."
+    ),
+)
+def get_polymarkets_with_pagination(
     limit: int,
-    closed: bool | None = False,
+    created_after: t.Optional[DatetimeUTC] = None,
+    active: bool | None = None,
+    closed: bool | None = None,
     excluded_questions: set[str] | None = None,
-    with_rewards: bool = False,
-    main_markets_only: bool = True,
-) -> list[PolymarketMarketWithPrices]:
+    only_binary: bool = True,
+    archived: bool = False,
+    ascending: bool = False,
+    order_by: PolymarketOrderByEnum = PolymarketOrderByEnum.VOLUME_24HR,
+) -> list[PolymarketGammaResponseDataItem]:
     """
-    See https://learn.polymarket.com/trading-rewards for information about rewards.
+    Binary markets have len(model.markets) == 1.
+    Categorical markets have len(model.markets) > 1
     """
-
-    all_markets: list[PolymarketMarketWithPrices] = []
-    next_cursor: str | None = None
-
-    while True:
-        response = get_polymarkets(
-            limit, with_rewards=with_rewards, next_cursor=next_cursor
+    client: httpx.Client = HttpxCachedClient(ttl=timedelta(seconds=60)).get_client()
+    all_markets: list[PolymarketGammaResponseDataItem] = []
+    offset = 0
+    remaining = limit
+
+    while remaining > 0:
+        # Calculate how many items to request in this batch (up to MARKETS_LIMIT or remaining)
+        # By default we fetch many markets because not possible to filter by binary/categorical
+        batch_size = MARKETS_LIMIT
+
+        # Build query parameters, excluding None values
+        params = {
+            "limit": batch_size,
+            "active": str(active).lower() if active is not None else None,
+            "archived": str(archived).lower(),
+            "closed": str(closed).lower() if closed is not None else None,
+            "order": order_by.value,
+            "ascending": str(ascending).lower(),
+            "offset": offset,
+        }
+        params_not_none = {k: v for k, v in params.items() if v is not None}
+        url = urljoin(
+            POLYMARKET_GAMMA_API_BASE_URL,
+            f"events/pagination",
         )
 
-        for market in response.data:
-            # Closed markets means resolved markets.
-            if closed is not None and market.closed != closed:
-                continue
+        r = client.get(url, params=params_not_none)
+        r.raise_for_status()
 
-            # Skip markets that are inactive.
-            # Documentation does not provide more details about this, but if API returns them, website gives "Oops...we didn't forecast this".
-            if not market.active:
-                continue
+        market_response = response_to_model(r, PolymarketGammaResponse)
 
-            # Skip also those that were archived.
-            # Again nothing about it in documentation and API doesn't seem to return them, but to be safe.
-            if market.archived:
+        markets_to_add = []
+        for m in market_response.data:
+            # Some Polymarket markets are missing the markets field
+            if m.markets is None or m.markets[0].clobTokenIds is None:
                 continue
-
-            if excluded_questions and market.question in excluded_questions:
+            if excluded_questions and m.title in excluded_questions:
                 continue
 
-            # Atm we work with binary markets only.
-            if sorted(token.outcome for token in market.tokens) != [
-                POLYMARKET_FALSE_OUTCOME,
-                POLYMARKET_TRUE_OUTCOME,
-            ]:
-                continue
+            sorted_outcome_list = sorted(m.markets[0].outcomes_list)
+            if only_binary:
+                # We keep markets that are only Yes,No
+                if len(m.markets) > 1 or sorted_outcome_list != [
+                    POLYMARKET_FALSE_OUTCOME,
+                    POLYMARKET_TRUE_OUTCOME,
+                ]:
+                    continue
 
-            # This is pretty slow to do here, but our safest option at the moment. So keep it as the last filter.
-            # TODO: Add support for `description` for `AgentMarket` and if it isn't None, use it in addition to the question in all agents. Then this can be removed.
-            if main_markets_only and not market.fetch_if_its_a_main_market():
+            if not m.startDate or (created_after and created_after > m.startDate):
                 continue
 
-            tokens_with_price = get_market_tokens_with_prices(market)
-            market_with_prices = PolymarketMarketWithPrices.model_validate(
-                {**market.model_dump(), "tokens": tokens_with_price}
-            )
+            markets_to_add.append(m)
 
-            all_markets.append(market_with_prices)
+        if only_binary:
+            markets_to_add = [
+                market
+                for market in markets_to_add
+                if market.markets is not None and len(market.markets) == 1
+            ]
 
-        if len(all_markets) >= limit:
-            break
+        # Add the markets from this batch to our results
+        all_markets.extend(markets_to_add)
 
-        next_cursor = response.next_cursor
+        # Update counters
+        offset += len(market_response.data)
+        remaining -= len(markets_to_add)
 
-        if next_cursor == "LTE=":
-            # 'LTE=' means the end.
+        # Stop if we've reached our limit or there are no more results
+        if (
+            remaining <= 0
+            or not market_response.pagination.hasMore
+            or len(market_response.data) == 0
+        ):
             break
 
+    # Return exactly the number of items requested (in case we got more due to batch size)
     return all_markets[:limit]
 
 
-def get_polymarket_market(condition_id: str) -> PolymarketMarket:
-    url = f"{POLYMARKET_API_BASE_URL}/markets/{condition_id}"
-    return response_to_model(requests.get(url), PolymarketMarket)
-
-
-def get_token_price(
-    token_id: str, side: t.Literal["buy", "sell"]
-) -> PolymarketPriceResponse:
-    url = f"{POLYMARKET_API_BASE_URL}/price"
-    params = {"token_id": token_id, "side": side}
-    return response_to_model(requests.get(url, params=params), PolymarketPriceResponse)
-
+@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}
 
-def get_market_tokens_with_prices(
-    market: PolymarketMarket,
-) -> list[PolymarketTokenWithPrices]:
-    tokens_with_prices = [
-        PolymarketTokenWithPrices(
-            token_id=token.token_id,
-            outcome=token.outcome,
-            winner=token.winner,
-            prices=Prices(
-                BUY=get_token_price(token.token_id, "buy").price_dec,
-                SELL=get_token_price(token.token_id, "sell").price_dec,
-            ),
-        )
-        for token in market.tokens
-    ]
-    return tokens_with_prices
+    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

@@ -1,15 +1,17 @@
+import json
+
 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,
-    PolymarketFullMarket,
-    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
@@ -26,6 +28,72 @@ class PolymarketToken(BaseModel):
     winner: bool
 
 
+class PolymarketGammaMarket(BaseModel):
+    conditionId: HexBytes
+    outcomes: str
+    outcomePrices: str | None = None
+    marketMakerAddress: str
+    createdAt: DatetimeUTC
+    updatedAt: DatetimeUTC | None = None
+    archived: bool
+    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)]
+
+    @property
+    def outcome_prices(self) -> list[float] | None:
+        if not self.outcomePrices:
+            return None
+        return [float(i) for i in json.loads(self.outcomePrices)]
+
+
+class PolymarketGammaTag(BaseModel):
+    label: str
+    slug: str
+
+
+class PolymarketGammaResponseDataItem(BaseModel):
+    id: str
+    slug: str
+    volume: float | None = None
+    startDate: DatetimeUTC | None = None
+    endDate: DatetimeUTC | None = None
+    liquidity: float | None = None
+    liquidityClob: float | None = None
+    title: str
+    description: str | None = None
+    archived: bool
+    closed: bool
+    active: bool
+    markets: list[
+        PolymarketGammaMarket
+    ] | None = None  # Some Polymarket markets have missing markets field. We skip these markets manually when retrieving.
+    tags: list[PolymarketGammaTag]
+
+    @property
+    def url(self) -> str:
+        return construct_polymarket_url(self.slug)
+
+
+class PolymarketGammaPagination(BaseModel):
+    hasMore: bool
+
+
+class PolymarketGammaResponse(BaseModel):
+    data: list[PolymarketGammaResponseDataItem]
+    pagination: PolymarketGammaPagination
+
+
 class PolymarketMarket(BaseModel):
     enable_order_book: bool
     active: bool
@@ -89,19 +157,6 @@ class PolymarketMarket(BaseModel):
                 f"Should not happen, invalid winner tokens: {winner_tokens}"
             )
 
-    def fetch_full_market(self) -> PolymarketFullMarket | None:
-        return PolymarketFullMarket.fetch_from_url(self.url)
-
-    def fetch_if_its_a_main_market(self) -> bool:
-        # On Polymarket, there are markets that are actually a group of multiple Yes/No markets, for example https://polymarket.com/event/presidential-election-winner-2024.
-        # But API returns them individually, and then we receive questions such as "Will any other Republican Politician win the 2024 US Presidential Election?",
-        # which are naturally unpredictable without futher details.
-        # This is a heuristic to filter them out.
-        # Warning: This is a very slow operation, as it requires fetching the website. Use it only when necessary.
-        full_market = self.fetch_full_market()
-        # `full_market` can be None, if this class come from a multiple Yes/No market, becase then, the constructed URL is invalid (and there is now way to construct an valid one from the data we have).
-        return full_market is not None and full_market.is_main_market
-
 
 class MarketsEndpointResponse(BaseModel):
     limit: int
@@ -138,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}"