polymarket_apis

37class AsyncPolymarketGraphQLClient:
38    """Asynchronous GraphQL client for Polymarket subgraphs."""
39
40    def __init__(
41        self,
42        endpoint_name: Literal[
43            "activity_subgraph",
44            "fpmm_subgraph",
45            "open_interest_subgraph",
46            "orderbook_subgraph",
47            "pnl_subgraph",
48            "positions_subgraph",
49            "sports_oracle_subgraph",
50            "wallet_subgraph",
51        ],
52    ) -> None:
53        endpoint_url = GRAPHQL_ENDPOINTS[endpoint_name]
54        self.transport = HTTPXAsyncTransport(url=endpoint_url)
55        self.client = Client(
56            transport=self.transport, fetch_schema_from_transport=False
57        )
58
59    async def query(self, query_string: str) -> dict:
60        async with self.client as session:
61            return await session.execute(gql(query_string))

439class MarketOrderArgs(BaseModel):
440    token_id: str
441    """
442    TokenID of the Conditional token asset being traded
443    """
444
445    amount: float
446    """
447    BUY orders: $$$ Amount to buy
448    SELL orders: Shares to sell
449    """
450
451    side: str
452    """
453    Side of the order
454    """
455
456    price: float = 0
457    """
458    Price used to create the order
459    """
460
461    fee_rate_bps: int = 0
462    """
463    Fee rate, in basis points, charged to the order maker, charged on proceeds.
464    """
465
466    nonce: int = 0
467    """
468    Nonce used for onchain cancellations.
469    """
470
471    taker: str = ADDRESS_ZERO
472    """
473    Address of the order taker. The zero address is used to indicate a public order.
474    """
475
476    order_type: OrderType = OrderType.FOK

397class OrderArgs(BaseModel):
398    token_id: str
399    """
400    TokenID of the Conditional token asset being traded
401    """
402
403    price: float
404    """
405    Price used to create the order
406    """
407
408    size: float
409    """
410    Size in terms of the ConditionalToken
411    """
412
413    side: str
414    """
415    Side of the order
416    """
417
418    fee_rate_bps: int = 0
419    """
420    Fee rate, in basis points, charged to the order maker, charged on proceeds
421    """
422
423    nonce: int = 0
424    """
425    Nonce used for onchain cancellations
426    """
427
428    expiration: int = 0
429    """
430    Timestamp after which the order is expired.
431    """
432
433    taker: str = ADDRESS_ZERO
434    """
435    Address of the order taker. The zero address is used to indicate a public order.
436    """

371class OrderType(str, Enum):
372    GTC = "GTC"  # Good Till Cancelled
373    GTD = "GTD"  # Good Till Date
374    FOK = "FOK"  # Fill or Kill
375    FAK = "FAK"  # Fill and Kill

 93class PolymarketClobClient:
 94    def __init__(
 95        self,
 96        private_key: str,
 97        address: EthAddress,
 98        creds: ApiCreds | None = None,
 99        chain_id: Literal[137, 80002] = POLYGON,
100        signature_type: Literal[0, 1, 2] = 1,
101        # 0 - EOA wallet, 1 - Proxy wallet, 2 - Gnosis Safe wallet
102    ):
103        self.address = address
104        self.client = httpx.Client(http2=True, timeout=30.0)
105        self.async_client = httpx.AsyncClient(http2=True, timeout=30.0)
106        self.base_url: str = "https://clob.polymarket.com"
107        self.signer = Signer(private_key=private_key, chain_id=chain_id)
108        self.builder = OrderBuilder(
109            signer=self.signer,
110            sig_type=signature_type,
111            funder=address,
112        )
113        self.creds = creds if creds else self.create_or_derive_api_creds()
114
115        # local cache
116        self.__tick_sizes: dict[str, TickSize] = {}
117        self.__neg_risk: dict[str, bool] = {}
118        self.__fee_rates: dict[str, int] = {}
119
120    def _build_url(self, endpoint: str) -> str:
121        return urljoin(self.base_url, endpoint)
122
123    def get_ok(self) -> str:
124        response = self.client.get(self.base_url)
125        response.raise_for_status()
126        return response.json()
127
128    def create_api_creds(self, nonce: int | None = None) -> ApiCreds:
129        headers = create_level_1_headers(self.signer, nonce)
130        response = self.client.post(self._build_url(CREATE_API_KEY), headers=headers)
131        response.raise_for_status()
132        return ApiCreds(**response.json())
133
134    def derive_api_key(self, nonce: int | None = None) -> ApiCreds:
135        headers = create_level_1_headers(self.signer, nonce)
136        response = self.client.get(self._build_url(DERIVE_API_KEY), headers=headers)
137        response.raise_for_status()
138        return ApiCreds(**response.json())
139
140    def create_or_derive_api_creds(self, nonce: int | None = None) -> ApiCreds:
141        try:
142            return self.create_api_creds(nonce)
143        except HTTPStatusError:
144            return self.derive_api_key(nonce)
145
146    def set_api_creds(self, creds: ApiCreds) -> None:
147        self.creds = creds
148
149    def get_api_keys(self) -> dict:
150        request_args = RequestArgs(method="GET", request_path=GET_API_KEYS)
151        headers = create_level_2_headers(self.signer, self.creds, request_args)
152        response = self.client.get(self._build_url(GET_API_KEYS), headers=headers)
153        response.raise_for_status()
154        return response.json()
155
156    def delete_api_keys(self) -> Literal["OK"]:
157        request_args = RequestArgs(method="DELETE", request_path=DELETE_API_KEY)
158        headers = create_level_2_headers(self.signer, self.creds, request_args)
159        response = self.client.delete(self._build_url(DELETE_API_KEY), headers=headers)
160        response.raise_for_status()
161        return response.json()
162
163    def get_utc_time(self) -> datetime:
164        # parse server timestamp into utc datetime
165        response = self.client.get(self._build_url(TIME))
166        response.raise_for_status()
167        return datetime.fromtimestamp(response.json(), tz=UTC)
168
169    def get_tick_size(self, token_id: str) -> TickSize:
170        if token_id in self.__tick_sizes:
171            return self.__tick_sizes[token_id]
172
173        params = {"token_id": token_id}
174        response = self.client.get(self._build_url(GET_TICK_SIZE), params=params)
175        response.raise_for_status()
176        self.__tick_sizes[token_id] = cast(
177            "TickSize", str(response.json()["minimum_tick_size"])
178        )
179
180        return self.__tick_sizes[token_id]
181
182    def get_neg_risk(self, token_id: str) -> bool:
183        if token_id in self.__neg_risk:
184            return self.__neg_risk[token_id]
185
186        params = {"token_id": token_id}
187        response = self.client.get(self._build_url(GET_NEG_RISK), params=params)
188        response.raise_for_status()
189        self.__neg_risk[token_id] = response.json()["neg_risk"]
190
191        return self.__neg_risk[token_id]
192
193    def get_fee_rate_bps(self, token_id: str) -> int:
194        if token_id in self.__fee_rates:
195            return self.__fee_rates[token_id]
196
197        params = {"token_id": token_id}
198        response = self.client.get(self._build_url(GET_FEE_RATE), params=params)
199        response.raise_for_status()
200        fee_rate = response.json().get("base_fee") or 0
201        self.__fee_rates[token_id] = fee_rate
202
203        return fee_rate
204
205    def __resolve_tick_size(
206        self,
207        token_id: str,
208        tick_size: TickSize | None = None,
209    ) -> TickSize:
210        min_tick_size = self.get_tick_size(token_id)
211        if tick_size is not None:
212            if is_tick_size_smaller(tick_size, min_tick_size):
213                msg = f"invalid tick size ({tick_size!s}), minimum for the market is {min_tick_size!s}"
214                raise InvalidTickSizeError(msg)
215        else:
216            tick_size = min_tick_size
217        return tick_size
218
219    def __resolve_fee_rate(
220        self,
221        token_id: str,
222        user_fee_rate: int | None = None,
223    ) -> int:
224        market_fee_rate_bps = self.get_fee_rate_bps(token_id)
225        # If both fee rate on the market and the user supplied fee rate are non-zero, validate that they match
226        # else return the market fee rate
227        if (
228            market_fee_rate_bps > 0
229            and user_fee_rate is not None
230            and user_fee_rate > 0
231            and user_fee_rate != market_fee_rate_bps
232        ):
233            msg = f"invalid user provided fee rate: ({user_fee_rate}), fee rate for the market must be {market_fee_rate_bps}"
234            raise InvalidFeeRateError(msg)
235        return market_fee_rate_bps
236
237    def get_midpoint(self, token_id: str) -> Midpoint:
238        """Get the mid-market price for the given token."""
239        params = {"token_id": token_id}
240        response = self.client.get(self._build_url(MID_POINT), params=params)
241        response.raise_for_status()
242        return Midpoint(token_id=token_id, value=float(response.json()["mid"]))
243
244    def get_midpoints(self, token_ids: list[str]) -> dict:
245        """Get the mid-market prices for a set of tokens."""
246        data = [{"token_id": token_id} for token_id in token_ids]
247        response = self.client.post(self._build_url(MID_POINTS), json=data)
248        response.raise_for_status()
249        return TokenValueDict(**response.json()).root
250
251    def get_spread(self, token_id: str) -> Spread:
252        """Get the spread for the given token."""
253        params = {"token_id": token_id}
254        response = self.client.get(self._build_url(GET_SPREAD), params=params)
255        response.raise_for_status()
256        return Spread(token_id=token_id, value=float(response.json()["mid"]))
257
258    def get_spreads(self, token_ids: list[str]) -> dict:
259        """Get the spreads for a set of tokens."""
260        data = [{"token_id": token_id} for token_id in token_ids]
261        response = self.client.post(self._build_url(GET_SPREADS), json=data)
262        response.raise_for_status()
263        return TokenValueDict(**response.json()).root
264
265    def get_price(self, token_id: str, side: Literal["BUY", "SELL"]) -> Price:
266        """Get the market price for the given token and side."""
267        params = {"token_id": token_id, "side": side}
268        response = self.client.get(self._build_url(PRICE), params=params)
269        response.raise_for_status()
270        return Price(**response.json(), token_id=token_id, side=side)
271
272    def get_prices(self, params: list[BookParams]) -> dict[str, BidAsk]:
273        """Get the market prices for a set of tokens and sides."""
274        data = [{"token_id": param.token_id, "side": param.side} for param in params]
275        response = self.client.post(self._build_url(GET_PRICES), json=data)
276        response.raise_for_status()
277        return TokenBidAskDict(**response.json()).root
278
279    def get_last_trade_price(self, token_id) -> Price:
280        """Fetches the last trade price for a token_id."""
281        params = {"token_id": token_id}
282        response = self.client.get(self._build_url(GET_LAST_TRADE_PRICE), params=params)
283        response.raise_for_status()
284        return Price(**response.json(), token_id=token_id)
285
286    def get_last_trades_prices(self, token_ids: list[str]) -> list[Price]:
287        """Fetches the last trades prices for a set of token ids."""
288        body = [{"token_id": token_id} for token_id in token_ids]
289        response = self.client.post(self._build_url(GET_LAST_TRADES_PRICES), json=body)
290        response.raise_for_status()
291        return [Price(**price) for price in response.json()]
292
293    def get_order_book(self, token_id) -> OrderBookSummary:
294        """Get the orderbook for the given token."""
295        params = {"token_id": token_id}
296        response = self.client.get(self._build_url(GET_ORDER_BOOK), params=params)
297        response.raise_for_status()
298        return OrderBookSummary(**response.json())
299
300    def get_order_books(self, token_ids: list[str]) -> list[OrderBookSummary]:
301        """Get the orderbook for a set of tokens."""
302        body = [{"token_id": token_id} for token_id in token_ids]
303        response = self.client.post(self._build_url(GET_ORDER_BOOKS), json=body)
304        response.raise_for_status()
305        return [OrderBookSummary(**obs) for obs in response.json()]
306
307    async def get_order_books_async(
308        self, token_ids: list[str]
309    ) -> list[OrderBookSummary]:
310        """Get the orderbook for a set of tokens asynchronously."""
311        body = [{"token_id": token_id} for token_id in token_ids]
312        response = await self.async_client.post(
313            self._build_url(GET_ORDER_BOOKS), json=body
314        )
315        response.raise_for_status()
316        return [OrderBookSummary(**obs) for obs in response.json()]
317
318    def get_market(self, condition_id) -> ClobMarket:
319        """Get a ClobMarket by condition_id."""
320        response = self.client.get(self._build_url(GET_MARKET + condition_id))
321        response.raise_for_status()
322        return ClobMarket(**response.json())
323
324    def get_markets(self, next_cursor="MA==") -> PaginatedResponse[ClobMarket]:
325        """Get paginated ClobMarkets."""
326        params = {"next_cursor": next_cursor}
327        response = self.client.get(self._build_url(GET_MARKETS), params=params)
328        response.raise_for_status()
329        return PaginatedResponse[ClobMarket](**response.json())
330
331    def get_all_markets(self, next_cursor="MA==") -> list[ClobMarket]:
332        """Recursively fetch all ClobMarkets using pagination."""
333        # Base case: Stop recursion if next_cursor indicates the last page
334        if next_cursor == "LTE=":
335            print("Reached the last page of markets.")
336            return []
337
338        # Fetch current page of markets
339        paginated_response = self.get_markets(next_cursor=next_cursor)
340
341        # Collect current page data
342        current_markets = paginated_response.data
343
344        # Recursively fetch remaining pages
345        next_page_markets = self.get_all_markets(
346            next_cursor=paginated_response.next_cursor,
347        )
348
349        # Combine current page data with data from subsequent pages
350        return current_markets + next_page_markets
351
352    def get_recent_history(
353        self,
354        token_id: str,
355        interval: Literal["1h", "6h", "1d", "1w", "1m", "max"] = "1d",
356        fidelity: int = 1,  # resolution in minutes
357    ) -> PriceHistory:
358        """Get the recent price history of a token (up to now) - 1h, 6h, 1d, 1w, 1m."""
359        min_fidelities: dict[str, int] = {
360            "1h": 1,
361            "6h": 1,
362            "1d": 1,
363            "1w": 5,
364            "1m": 10,
365            "max": 2,
366        }
367
368        if fidelity < min_fidelities[interval]:
369            msg = f"invalid filters: minimum fidelity' for '{interval}' range is {min_fidelities.get(interval)}"
370            raise ValueError(msg)
371
372        params: dict[str, int | str] = {
373            "market": token_id,
374            "interval": interval,
375            "fidelity": fidelity,
376        }
377        response = self.client.get(self._build_url("/prices-history"), params=params)
378        response.raise_for_status()
379        return PriceHistory(**response.json(), token_id=token_id)
380
381    def get_history(
382        self,
383        token_id: str,
384        start_time: datetime | None = None,
385        end_time: datetime | None = None,
386        fidelity: int = 2,  # resolution in minutes
387    ) -> PriceHistory:
388        """Get the price history of a token between a selected date range of max 15 days or from start_time to now."""
389        if start_time is None and end_time is None:
390            msg = "At least 'start_time' or ('start_time' and 'end_time') must be provided"
391            raise ValueError(msg)
392
393        if (
394            start_time
395            and end_time
396            and start_time + timedelta(days=15, seconds=1) < end_time
397        ):
398            msg = "'start_time' - 'end_time' range cannot exceed 15 days. Remove 'end_time' to get prices up to now or set a shorter range."
399            raise ValueError(msg)
400
401        params: dict[str, int | str] = {
402            "market": token_id,
403            "fidelity": fidelity,
404        }
405        if start_time:
406            params["startTs"] = int(start_time.timestamp())
407        if end_time:
408            params["endTs"] = int(end_time.timestamp())
409
410        response = self.client.get(self._build_url("/prices-history"), params=params)
411        response.raise_for_status()
412        return PriceHistory(**response.json(), token_id=token_id)
413
414    def get_all_history(self, token_id: str) -> PriceHistory:
415        """Get the full price history of a token."""
416        return self.get_history(
417            token_id=token_id,
418            start_time=datetime(2020, 1, 1, tzinfo=UTC),
419        )
420
421    def get_orders(
422        self,
423        order_id: str | None = None,
424        condition_id: Keccak256 | None = None,
425        token_id: str | None = None,
426        next_cursor: str = "MA==",
427    ) -> list[OpenOrder]:
428        """Gets your active orders, filtered by order_id, condition_id, token_id."""
429        params = {}
430        if order_id:
431            params["id"] = order_id
432        if condition_id:
433            params["market"] = condition_id
434        if token_id:
435            params["asset_id"] = token_id
436
437        request_args = RequestArgs(method="GET", request_path=ORDERS)
438        headers = create_level_2_headers(self.signer, self.creds, request_args)
439
440        results = []
441        next_cursor = next_cursor if next_cursor is not None else "MA=="
442        while next_cursor != END_CURSOR:
443            params["next_cursor"] = next_cursor
444            response = self.client.get(
445                self._build_url(ORDERS), headers=headers, params=params
446            )
447            response.raise_for_status()
448            next_cursor = response.json()["next_cursor"]
449            results += [OpenOrder(**order) for order in response.json()["data"]]
450
451        return results
452
453    def create_order(
454        self, order_args: OrderArgs, options: PartialCreateOrderOptions | None = None
455    ) -> SignedOrder:
456        """Creates and signs an order."""
457        # add resolve_order_options, or similar
458        tick_size = self.__resolve_tick_size(
459            order_args.token_id,
460            options.tick_size if options else None,
461        )
462
463        if not price_valid(order_args.price, tick_size):
464            msg = f"price ({order_args.price}), min: {tick_size} - max: {1 - float(tick_size)}"
465            raise InvalidPriceError(msg)
466
467        neg_risk = (
468            options.neg_risk
469            if options and options.neg_risk is not None
470            else self.get_neg_risk(order_args.token_id)
471        )
472
473        # fee rate
474        fee_rate_bps = self.__resolve_fee_rate(
475            order_args.token_id, order_args.fee_rate_bps
476        )
477        order_args.fee_rate_bps = fee_rate_bps
478
479        return self.builder.create_order(
480            order_args,
481            CreateOrderOptions(
482                tick_size=tick_size,
483                neg_risk=neg_risk,
484            ),
485        )
486
487    def post_order(
488        self, order: SignedOrder, order_type: OrderType = OrderType.GTC
489    ) -> OrderPostResponse | None:
490        """Posts a SignedOrder."""
491        body = order_to_json(order, self.creds.key, order_type)
492        headers = create_level_2_headers(
493            self.signer,
494            self.creds,
495            RequestArgs(method="POST", request_path=POST_ORDER, body=body),
496        )
497
498        try:
499            response = self.client.post(
500                self._build_url("/order"),
501                headers=headers,
502                content=json.dumps(body).encode("utf-8"),
503            )
504            response.raise_for_status()
505            return OrderPostResponse(**response.json())
506        except httpx.HTTPStatusError as exc:
507            msg = f"Client Error '{exc.response.status_code} {exc.response.reason_phrase}' while posting order"
508            logger.warning(msg)
509            error_json = exc.response.json()
510            print("Details:", error_json["error"])
511            return None
512
513    def create_and_post_order(
514        self,
515        order_args: OrderArgs,
516        options: PartialCreateOrderOptions | None = None,
517        order_type: OrderType = OrderType.GTC,
518    ) -> OrderPostResponse | None:
519        """Utility function to create and publish an order."""
520        order = self.create_order(order_args, options)
521        return self.post_order(order=order, order_type=order_type)
522
523    def post_orders(self, args: list[PostOrdersArgs]) -> list[OrderPostResponse] | None:
524        """Posts multiple SignedOrders at once."""
525        body = [
526            order_to_json(arg.order, self.creds.key, arg.order_type) for arg in args
527        ]
528        headers = create_level_2_headers(
529            self.signer,
530            self.creds,
531            RequestArgs(method="POST", request_path=POST_ORDERS, body=body),
532        )
533
534        try:
535            response = self.client.post(
536                self._build_url("/orders"),
537                headers=headers,
538                content=json.dumps(body).encode("utf-8"),
539            )
540            response.raise_for_status()
541            order_responses = []
542            for index, item in enumerate(response.json()):
543                resp = OrderPostResponse(**item)
544                order_responses.append(resp)
545                if resp.error_msg:
546                    msg = (
547                        f"Error posting order in position {index} \n"
548                        f"Details: {resp.error_msg}"
549                    )
550                    logger.warning(msg)
551        except httpx.HTTPStatusError as exc:
552            msg = f"Client Error '{exc.response.status_code} {exc.response.reason_phrase}' while posting order"
553            logger.warning(msg)
554            error_json = exc.response.json()
555            print("Details:", error_json["error"])
556            return None
557        else:
558            return order_responses
559
560    def create_and_post_orders(
561        self, args: list[OrderArgs], order_types: list[OrderType]
562    ) -> list[OrderPostResponse] | None:
563        """Utility function to create and publish multiple orders at once."""
564        return self.post_orders(
565            [
566                PostOrdersArgs(
567                    order=self.create_order(order_args), order_type=order_type
568                )
569                for order_args, order_type in zip(args, order_types, strict=True)
570            ],
571        )
572
573    def calculate_market_price(
574        self, token_id: str, side: str, amount: float, order_type: OrderType
575    ) -> float:
576        """Calculates the matching price considering an amount and the current orderbook."""
577        book = self.get_order_book(token_id)
578        if book is None:
579            msg = "Order book is None"
580            raise MissingOrderbookError(msg)
581        if side == "BUY":
582            if book.asks is None:
583                msg = "No ask orders available"
584                raise LiquidityError(msg)
585            return self.builder.calculate_buy_market_price(
586                book.asks,
587                amount,
588                order_type,
589            )
590        if side == "SELL":
591            if book.bids is None:
592                msg = "No bid orders available"
593                raise LiquidityError(msg)
594            return self.builder.calculate_sell_market_price(
595                book.bids,
596                amount,
597                order_type,
598            )
599        msg = 'Side must be "BUY" or "SELL"'
600        raise ValueError(msg)
601
602    def create_market_order(
603        self,
604        order_args: MarketOrderArgs,
605        options: PartialCreateOrderOptions | None = None,
606    ):
607        """Creates and signs a market order."""
608        tick_size = self.__resolve_tick_size(
609            order_args.token_id,
610            options.tick_size if options else None,
611        )
612
613        if order_args.price is None or order_args.price <= 0:
614            order_args.price = self.calculate_market_price(
615                order_args.token_id,
616                order_args.side,
617                order_args.amount,
618                order_args.order_type,
619            )
620
621        if not price_valid(order_args.price, tick_size):
622            msg = f"price ({order_args.price}), min: {tick_size} - max: {1 - float(tick_size)}"
623            raise InvalidPriceError(msg)
624
625        neg_risk = (
626            options.neg_risk
627            if options and options.neg_risk is not None
628            else self.get_neg_risk(order_args.token_id)
629        )
630
631        # fee rate
632        fee_rate_bps = self.__resolve_fee_rate(
633            order_args.token_id, order_args.fee_rate_bps
634        )
635        order_args.fee_rate_bps = fee_rate_bps
636
637        return self.builder.create_market_order(
638            order_args,
639            CreateOrderOptions(
640                tick_size=tick_size,
641                neg_risk=neg_risk,
642            ),
643        )
644
645    def create_and_post_market_order(
646        self,
647        order_args: MarketOrderArgs,
648        options: PartialCreateOrderOptions | None = None,
649        order_type: OrderType = OrderType.FOK,
650    ) -> OrderPostResponse | None:
651        """Utility function to create and publish a market order."""
652        order = self.create_market_order(order_args, options)
653        return self.post_order(order=order, order_type=order_type)
654
655    def cancel_order(self, order_id: Keccak256) -> OrderCancelResponse:
656        """Cancels an order."""
657        body = {"orderID": order_id}
658
659        request_args = RequestArgs(method="DELETE", request_path=CANCEL, body=body)
660        headers = create_level_2_headers(self.signer, self.creds, request_args)
661
662        response = self.client.request(
663            "DELETE",
664            self._build_url(CANCEL),
665            headers=headers,
666            content=json.dumps(body).encode("utf-8"),
667        )
668        response.raise_for_status()
669        return OrderCancelResponse(**response.json())
670
671    def cancel_orders(self, order_ids: list[Keccak256]) -> OrderCancelResponse:
672        """Cancels orders."""
673        body = order_ids
674
675        request_args = RequestArgs(
676            method="DELETE",
677            request_path=CANCEL_ORDERS,
678            body=body,
679        )
680        headers = create_level_2_headers(self.signer, self.creds, request_args)
681
682        response = self.client.request(
683            "DELETE",
684            self._build_url(CANCEL_ORDERS),
685            headers=headers,
686            content=json.dumps(body).encode("utf-8"),
687        )
688        response.raise_for_status()
689        return OrderCancelResponse(**response.json())
690
691    def cancel_all(self) -> OrderCancelResponse:
692        """Cancels all available orders for the user."""
693        request_args = RequestArgs(method="DELETE", request_path=CANCEL_ALL)
694        headers = create_level_2_headers(self.signer, self.creds, request_args)
695
696        response = self.client.delete(self._build_url(CANCEL_ALL), headers=headers)
697        response.raise_for_status()
698        return OrderCancelResponse(**response.json())
699
700    def is_order_scoring(self, order_id: Keccak256) -> bool:
701        """Check if the order is currently scoring."""
702        request_args = RequestArgs(method="GET", request_path=IS_ORDER_SCORING)
703        headers = create_level_2_headers(self.signer, self.creds, request_args)
704
705        response = self.client.get(
706            self._build_url(IS_ORDER_SCORING),
707            headers=headers,
708            params={"order_id": order_id},
709        )
710        response.raise_for_status()
711        return response.json()["scoring"]
712
713    def are_orders_scoring(self, order_ids: list[Keccak256]) -> dict[Keccak256, bool]:
714        """Check if the orders are currently scoring."""
715        body = order_ids
716        request_args = RequestArgs(
717            method="POST",
718            request_path=ARE_ORDERS_SCORING,
719            body=body,
720        )
721        headers = create_level_2_headers(self.signer, self.creds, request_args)
722        headers["Content-Type"] = "application/json"
723
724        response = self.client.post(
725            self._build_url(ARE_ORDERS_SCORING), headers=headers, json=body
726        )
727        response.raise_for_status()
728        return response.json()
729
730    def get_market_rewards(self, condition_id: Keccak256) -> MarketRewards:
731        """
732        Get the MarketRewards for a given market (condition_id).
733
734        - metadata, tokens, max_spread, min_size, rewards_config, market_competitiveness.
735        """
736        request_args = RequestArgs(method="GET", request_path="/rewards/markets/")
737        headers = create_level_2_headers(self.signer, self.creds, request_args)
738
739        response = self.client.get(
740            self._build_url("/rewards/markets/" + condition_id), headers=headers
741        )
742        response.raise_for_status()
743        return next(MarketRewards(**market) for market in response.json()["data"])
744
745    def get_trades(
746        self,
747        condition_id: Keccak256 | None = None,
748        token_id: str | None = None,
749        trade_id: str | None = None,
750        before: datetime | None = None,
751        after: datetime | None = None,
752        address: EthAddress | None = None,
753        next_cursor="MA==",
754    ) -> list[PolygonTrade]:
755        """Fetches the trade history for a user."""
756        params: dict[str, str | int] = {}
757        if condition_id:
758            params["market"] = condition_id
759        if token_id:
760            params["asset_id"] = token_id
761        if trade_id:
762            params["id"] = trade_id
763        if before:
764            params["before"] = int(before.replace(microsecond=0).timestamp())
765        if after:
766            params["after"] = int(after.replace(microsecond=0).timestamp())
767        if address:
768            params["maker_address"] = address
769
770        request_args = RequestArgs(method="GET", request_path=TRADES)
771        headers = create_level_2_headers(self.signer, self.creds, request_args)
772
773        results = []
774        next_cursor = next_cursor if next_cursor is not None else "MA=="
775        while next_cursor != END_CURSOR:
776            params["next_cursor"] = next_cursor
777            response = self.client.get(
778                self._build_url(TRADES), headers=headers, params=params
779            )
780            response.raise_for_status()
781            next_cursor = response.json()["next_cursor"]
782            results += [PolygonTrade(**trade) for trade in response.json()["data"]]
783
784        return results
785
786    def get_total_rewards(self, date: datetime | None = None) -> DailyEarnedReward:
787        """Get the total rewards earned on a given date (seems to only hold the 6 most recent data points)."""
788        if date is None:
789            date = datetime.now(UTC)
790        params = {
791            "authenticationType": "magic",
792            "date": f"{date.strftime('%Y-%m-%d')}",
793        }
794
795        request_args = RequestArgs(method="GET", request_path="/rewards/user/total")
796        headers = create_level_2_headers(self.signer, self.creds, request_args)
797        params["l2Headers"] = json.dumps(headers)
798
799        response = self.client.get(
800            "https://polymarket.com/api/rewards/totalEarnings", params=params
801        )
802        response.raise_for_status()
803        if response.json():
804            return DailyEarnedReward(**response.json()[0])
805        return DailyEarnedReward(
806            date=date,
807            asset_address="0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174",
808            maker_address=self.address,
809            earnings=0.0,
810            asset_rate=0.0,
811        )
812
813    def get_reward_markets(
814        self,
815        query: str | None = None,
816        sort_by: Literal[
817            "market",
818            "max_spread",
819            "min_size",
820            "rate_per_day",
821            "spread",
822            "price",
823            "earnings",
824            "earning_percentage",
825        ]
826        | None = "market",
827        sort_direction: Literal["ASC", "DESC"] | None = None,
828        show_favorites: bool = False,
829    ) -> list[RewardMarket]:
830        """
831        Search through markets that offer rewards (polymarket.com/rewards items) by query, sorted by different metrics. If query is empty, returns all markets with rewards.
832
833         - market start date ("market") - TODO confirm this
834         - max spread for rewards in usdc
835         - min size for rewards in shares
836         - reward rate per day in usdc
837         - current spread of a market
838         - current price of a market
839         - your daily earnings on a market - only need auth for these last two
840         - your current earning percentage on a market.
841        """
842        results = []
843        desc = {"ASC": False, "DESC": True}
844        params: dict[str, bool | str] = {
845            "authenticationType": "magic",
846            "showFavorites": show_favorites,
847        }
848        if sort_by:
849            params["orderBy"] = sort_by
850        if query:
851            params["query"] = query
852            params["desc"] = False
853        if sort_direction:
854            params["desc"] = desc[sort_direction]
855
856        request_args = RequestArgs(method="GET", request_path="/rewards/user/markets")
857        headers = create_level_2_headers(self.signer, self.creds, request_args)
858        params["l2Headers"] = json.dumps(headers)
859
860        next_cursor = "MA=="
861        while next_cursor != END_CURSOR:
862            params["nextCursor"] = next_cursor
863            response = self.client.get(
864                "https://polymarket.com/api/rewards/markets", params=params
865            )
866            response.raise_for_status()
867            next_cursor = response.json()["next_cursor"]
868            results += [RewardMarket(**reward) for reward in response.json()["data"]]
869
870        return results
871
872    def __enter__(self):
873        return self
874
875    def __exit__(self, exc_type, exc_val, exc_tb):
876        self.client.close()