polymarket-apis 0.3.6__py3-none-any.whl → 0.3.7__py3-none-any.whl

polymarket_apis/__init__.py

@@ -10,7 +10,7 @@ This package provides a comprehensive interface to Polymarket's APIs including:
 - GraphQL API for flexible data queries
 """
 
-__version__ = "0.3.6"
+__version__ = "0.3.7"
 __author__ = "Razvan Gheorghe"
 __email__ = "razvan@gheorghe.me"
 

polymarket_apis/clients/clob_client.py

@@ -1,7 +1,7 @@
 import json
 import logging
 from datetime import UTC, datetime, timedelta
-from typing import Literal, Optional
+from typing import Literal, cast
 from urllib.parse import urljoin
 
 import httpx
@@ -94,7 +94,7 @@ class PolymarketClobClient:
         self,
         private_key: str,
         address: EthAddress,
-        creds: Optional[ApiCreds] = None,
+        creds: ApiCreds | None = None,
         chain_id: Literal[137, 80002] = POLYGON,
         signature_type: Literal[0, 1, 2] = 1,
         # 0 - EOA wallet, 1 - Proxy wallet, 2 - Gnosis Safe wallet
@@ -112,9 +112,9 @@ class PolymarketClobClient:
         self.creds = creds if creds else self.create_or_derive_api_creds()
 
         # local cache
-        self.__tick_sizes = {}
-        self.__neg_risk = {}
-        self.__fee_rates = {}
+        self.__tick_sizes: dict[str, TickSize] = {}
+        self.__neg_risk: dict[str, bool] = {}
+        self.__fee_rates: dict[str, int] = {}
 
     def _build_url(self, endpoint: str) -> str:
         return urljoin(self.base_url, endpoint)
@@ -124,19 +124,19 @@ class PolymarketClobClient:
         response.raise_for_status()
         return response.json()
 
-    def create_api_creds(self, nonce: Optional[int] = None) -> ApiCreds:
+    def create_api_creds(self, nonce: int | None = None) -> ApiCreds:
         headers = create_level_1_headers(self.signer, nonce)
         response = self.client.post(self._build_url(CREATE_API_KEY), headers=headers)
         response.raise_for_status()
         return ApiCreds(**response.json())
 
-    def derive_api_key(self, nonce: Optional[int] = None) -> ApiCreds:
+    def derive_api_key(self, nonce: int | None = None) -> ApiCreds:
         headers = create_level_1_headers(self.signer, nonce)
         response = self.client.get(self._build_url(DERIVE_API_KEY), headers=headers)
         response.raise_for_status()
         return ApiCreds(**response.json())
 
-    def create_or_derive_api_creds(self, nonce: Optional[int] = None) -> ApiCreds:
+    def create_or_derive_api_creds(self, nonce: int | None = None) -> ApiCreds:
         try:
             return self.create_api_creds(nonce)
         except HTTPStatusError:
@@ -172,7 +172,9 @@ class PolymarketClobClient:
         params = {"token_id": token_id}
         response = self.client.get(self._build_url(GET_TICK_SIZE), params=params)
         response.raise_for_status()
-        self.__tick_sizes[token_id] = str(response.json()["minimum_tick_size"])
+        self.__tick_sizes[token_id] = cast(
+            "TickSize", str(response.json()["minimum_tick_size"])
+        )
 
         return self.__tick_sizes[token_id]
 
@@ -202,7 +204,7 @@ class PolymarketClobClient:
     def __resolve_tick_size(
         self,
         token_id: str,
-        tick_size: TickSize = None,
+        tick_size: TickSize | None = None,
     ) -> TickSize:
         min_tick_size = self.get_tick_size(token_id)
         if tick_size is not None:
@@ -216,7 +218,7 @@ class PolymarketClobClient:
     def __resolve_fee_rate(
         self,
         token_id: str,
-        user_fee_rate: Optional[int] = None,
+        user_fee_rate: int | None = None,
     ) -> int:
         market_fee_rate_bps = self.get_fee_rate_bps(token_id)
         # If both fee rate on the market and the user supplied fee rate are non-zero, validate that they match
@@ -362,11 +364,11 @@ class PolymarketClobClient:
             "max": 2,
         }
 
-        if fidelity < min_fidelities.get(interval):
-            msg = f"invalid filters: minimum 'fidelity' for '{interval}' range is {min_fidelities.get(interval)}"
+        if fidelity < min_fidelities[interval]:
+            msg = f"invalid filters: minimum fidelity' for '{interval}' range is {min_fidelities.get(interval)}"
             raise ValueError(msg)
 
-        params = {
+        params: dict[str, int | str] = {
             "market": token_id,
             "interval": interval,
             "fidelity": fidelity,
@@ -378,8 +380,8 @@ class PolymarketClobClient:
     def get_history(
         self,
         token_id: str,
-        start_time: Optional[datetime] = None,
-        end_time: Optional[datetime] = None,
+        start_time: datetime | None = None,
+        end_time: datetime | None = None,
         fidelity: int = 2,  # resolution in minutes
     ) -> PriceHistory:
         """Get the price history of a token between a selected date range of max 15 days or from start_time to now."""
@@ -395,7 +397,7 @@ class PolymarketClobClient:
             msg = "'start_time' - 'end_time' range cannot exceed 15 days. Remove 'end_time' to get prices up to now or set a shorter range."
             raise ValueError(msg)
 
-        params = {
+        params: dict[str, int | str] = {
             "market": token_id,
             "fidelity": fidelity,
         }
@@ -417,9 +419,9 @@ class PolymarketClobClient:
 
     def get_orders(
         self,
-        order_id: Optional[str] = None,
-        condition_id: Optional[Keccak256] = None,
-        token_id: Optional[str] = None,
+        order_id: str | None = None,
+        condition_id: Keccak256 | None = None,
+        token_id: str | None = None,
         next_cursor: str = "MA==",
     ) -> list[OpenOrder]:
         """Gets your active orders, filtered by order_id, condition_id, token_id."""
@@ -448,7 +450,7 @@ class PolymarketClobClient:
         return results
 
     def create_order(
-        self, order_args: OrderArgs, options: Optional[PartialCreateOrderOptions] = None
+        self, order_args: OrderArgs, options: PartialCreateOrderOptions | None = None
     ) -> SignedOrder:
         """Creates and signs an order."""
         # add resolve_order_options, or similar
@@ -483,7 +485,7 @@ class PolymarketClobClient:
 
     def post_order(
         self, order: SignedOrder, order_type: OrderType = OrderType.GTC
-    ) -> Optional[OrderPostResponse]:
+    ) -> OrderPostResponse | None:
         """Posts a SignedOrder."""
         body = order_to_json(order, self.creds.key, order_type)
         headers = create_level_2_headers(
@@ -505,18 +507,19 @@ class PolymarketClobClient:
             logger.warning(msg)
             error_json = exc.response.json()
             print("Details:", error_json["error"])
+            return None
 
     def create_and_post_order(
         self,
         order_args: OrderArgs,
-        options: Optional[PartialCreateOrderOptions] = None,
+        options: PartialCreateOrderOptions | None = None,
         order_type: OrderType = OrderType.GTC,
     ) -> OrderPostResponse | None:
         """Utility function to create and publish an order."""
         order = self.create_order(order_args, options)
         return self.post_order(order=order, order_type=order_type)
 
-    def post_orders(self, args: list[PostOrdersArgs]):
+    def post_orders(self, args: list[PostOrdersArgs]) -> list[OrderPostResponse] | None:
         """Posts multiple SignedOrders at once."""
         body = [
             order_to_json(arg.order, self.creds.key, arg.order_type) for arg in args
@@ -549,12 +552,13 @@ class PolymarketClobClient:
             logger.warning(msg)
             error_json = exc.response.json()
             print("Details:", error_json["error"])
+            return None
         else:
             return order_responses
 
     def create_and_post_orders(
         self, args: list[OrderArgs], order_types: list[OrderType]
-    ) -> list[OrderPostResponse]:
+    ) -> list[OrderPostResponse] | None:
         """Utility function to create and publish multiple orders at once."""
         return self.post_orders(
             [
@@ -597,7 +601,7 @@ class PolymarketClobClient:
     def create_market_order(
         self,
         order_args: MarketOrderArgs,
-        options: Optional[PartialCreateOrderOptions] = None,
+        options: PartialCreateOrderOptions | None = None,
     ):
         """Creates and signs a market order."""
         tick_size = self.__resolve_tick_size(
@@ -640,7 +644,7 @@ class PolymarketClobClient:
     def create_and_post_market_order(
         self,
         order_args: MarketOrderArgs,
-        options: Optional[PartialCreateOrderOptions] = None,
+        options: PartialCreateOrderOptions | None = None,
         order_type: OrderType = OrderType.FOK,
     ) -> OrderPostResponse | None:
         """Utility function to create and publish a market order."""
@@ -678,7 +682,7 @@ class PolymarketClobClient:
             "DELETE",
             self._build_url(CANCEL_ORDERS),
             headers=headers,
-            data=json.dumps(body).encode("utf-8"),
+            content=json.dumps(body).encode("utf-8"),
         )
         response.raise_for_status()
         return OrderCancelResponse(**response.json())
@@ -739,12 +743,12 @@ class PolymarketClobClient:
 
     def get_trades(
         self,
-        condition_id: Optional[Keccak256] = None,
-        token_id: Optional[str] = None,
-        trade_id: Optional[str] = None,
-        before: Optional[datetime] = None,
-        after: Optional[datetime] = None,
-        address: Optional[EthAddress] = None,
+        condition_id: Keccak256 | None = None,
+        token_id: str | None = None,
+        trade_id: str | None = None,
+        before: datetime | None = None,
+        after: datetime | None = None,
+        address: EthAddress | None = None,
         next_cursor="MA==",
     ) -> list[PolygonTrade]:
         """Fetches the trade history for a user."""
@@ -778,7 +782,7 @@ class PolymarketClobClient:
 
         return results
 
-    def get_total_rewards(self, date: Optional[datetime] = None) -> DailyEarnedReward:
+    def get_total_rewards(self, date: datetime | None = None) -> DailyEarnedReward:
         """Get the total rewards earned on a given date (seems to only hold the 6 most recent data points)."""
         if date is None:
             date = datetime.now(UTC)
@@ -807,20 +811,19 @@ class PolymarketClobClient:
 
     def get_reward_markets(
         self,
-        query: Optional[str] = None,
-        sort_by: Optional[
-            Literal[
-                "market",
-                "max_spread",
-                "min_size",
-                "rate_per_day",
-                "spread",
-                "price",
-                "earnings",
-                "earning_percentage",
-            ]
-        ] = "market",
-        sort_direction: Optional[Literal["ASC", "DESC"]] = None,
+        query: str | None = None,
+        sort_by: Literal[
+            "market",
+            "max_spread",
+            "min_size",
+            "rate_per_day",
+            "spread",
+            "price",
+            "earnings",
+            "earning_percentage",
+        ]
+        | None = "market",
+        sort_direction: Literal["ASC", "DESC"] | None = None,
         show_favorites: bool = False,
     ) -> list[RewardMarket]:
         """
@@ -837,7 +840,7 @@ class PolymarketClobClient:
         """
         results = []
         desc = {"ASC": False, "DESC": True}
-        params = {
+        params: dict[str, bool | str] = {
             "authenticationType": "magic",
             "showFavorites": show_favorites,
         }

polymarket_apis/clients/data_client.py

@@ -222,7 +222,11 @@ class PolymarketDataClient:
         min_balance: int = 1,
     ) -> list[HolderResponse]:
         """Takes in a condition_id and returns top holders for each corresponding token_id."""
-        params = {"market": condition_id, "limit": limit, "min_balance": min_balance}
+        params: dict[str, int | str] = {
+            "market": condition_id,
+            "limit": limit,
+            "min_balance": min_balance,
+        }
         response = self.client.get(self._build_url("/holders"), params=params)
         response.raise_for_status()
         return [HolderResponse(**holder_data) for holder_data in response.json()]
@@ -332,7 +336,7 @@ class PolymarketDataClient:
         window: Literal["1d", "7d", "30d", "all"] = "all",
     ):
         """Get a user's overall profit or volume in the last day, week, month or all."""
-        params = {
+        params: dict[str, int | str] = {
             "address": user,
             "window": window,
             "limit": 1,

polymarket_apis/clients/gamma_client.py

@@ -104,29 +104,29 @@ class PolymarketGammaClient:
 
     def get_markets(
         self,
-        limit: Optional[int] = None,
-        offset: Optional[int] = None,
-        order: Optional[str] = None,
+        limit: int | None = None,
+        offset: int | None = None,
+        order: str | None = None,
         ascending: bool = True,
-        archived: Optional[bool] = None,
-        active: Optional[bool] = None,
-        closed: Optional[bool] = None,
-        slugs: Optional[list[str]] = None,
-        market_ids: Optional[list[int]] = None,
-        token_ids: Optional[list[str]] = None,
-        condition_ids: Optional[list[str]] = None,
-        tag_id: Optional[int] = None,
-        related_tags: Optional[bool] = False,
-        liquidity_num_min: Optional[float] = None,
-        liquidity_num_max: Optional[float] = None,
-        volume_num_min: Optional[float] = None,
-        volume_num_max: Optional[float] = None,
-        start_date_min: Optional[datetime] = None,
-        start_date_max: Optional[datetime] = None,
-        end_date_min: Optional[datetime] = None,
-        end_date_max: Optional[datetime] = None,
+        archived: bool | None = None,
+        active: bool | None = None,
+        closed: bool | None = None,
+        slugs: list[str] | None = None,
+        market_ids: list[int] | None = None,
+        token_ids: list[str] | None = None,
+        condition_ids: list[str] | None = None,
+        tag_id: int | None = None,
+        related_tags: bool | None = False,
+        liquidity_num_min: float | None = None,
+        liquidity_num_max: float | None = None,
+        volume_num_min: float | None = None,
+        volume_num_max: float | None = None,
+        start_date_min: datetime | None = None,
+        start_date_max: datetime | None = None,
+        end_date_min: datetime | None = None,
+        end_date_max: datetime | None = None,
     ) -> list[GammaMarket]:
-        params = {}
+        params: dict[str, float | int | list[int] | str | list[str] | bool] = {}
         if limit:
             params["limit"] = limit
         if offset:

polymarket_apis/clients/web3_client.py

@@ -1,10 +1,15 @@
 from json import load
 from pathlib import Path
-from typing import Literal, Optional
+from typing import Literal
 
 from web3 import Web3
+from web3.constants import MAX_INT
 from web3.exceptions import ContractCustomError
-from web3.middleware import ExtraDataToPOAMiddleware, SignAndSendRawMiddlewareBuilder
+from web3.middleware import (
+    ExtraDataToPOAMiddleware,
+    SignAndSendRawMiddlewareBuilder,
+)
+from web3.types import ChecksumAddress, TxParams, Wei
 
 from ..types.common import EthAddress, Keccak256
 from ..utilities.config import get_contract_config
@@ -36,9 +41,10 @@ class PolymarketWeb3Client:
         chain_id: Literal[137, 80002] = POLYGON,
     ):
         self.w3 = Web3(Web3.HTTPProvider("https://polygon-rpc.com"))
-        self.w3.middleware_onion.inject(ExtraDataToPOAMiddleware, layer=0)
+        self.w3.middleware_onion.inject(ExtraDataToPOAMiddleware, layer=0)  # type: ignore[arg-type]
         self.w3.middleware_onion.inject(
-            SignAndSendRawMiddlewareBuilder.build(private_key), layer=0
+            SignAndSendRawMiddlewareBuilder.build(private_key),  # type: ignore[arg-type]
+            layer=0,
         )
 
         self.account = self.w3.eth.account.from_key(private_key)
@@ -71,19 +77,25 @@ class PolymarketWeb3Client:
             self.neg_risk_exchange_address, self.neg_risk_exchange_abi
         )
 
-        self.neg_risk_adapter_address = "0xd91E80cF2E7be2e162c6513ceD06f1dD0dA35296"
+        self.neg_risk_adapter_address = Web3.to_checksum_address(
+            "0xd91E80cF2E7be2e162c6513ceD06f1dD0dA35296"
+        )
         self.neg_risk_adapter_abi = _load_abi("NegRiskAdapter")
         self.neg_risk_adapter = self.contract(
             self.neg_risk_adapter_address, self.neg_risk_adapter_abi
         )
 
-        self.proxy_factory_address = "0xaB45c5A4B0c941a2F231C04C3f49182e1A254052"
+        self.proxy_factory_address = Web3.to_checksum_address(
+            "0xaB45c5A4B0c941a2F231C04C3f49182e1A254052"
+        )
         self.proxy_factory_abi = _load_abi("ProxyWalletFactory")
         self.proxy_factory = self.contract(
             self.proxy_factory_address, self.proxy_factory_abi
         )
 
-        self.safe_proxy_factory_address = "0xaacFeEa03eb1561C4e67d661e40682Bd20E3541b"
+        self.safe_proxy_factory_address = Web3.to_checksum_address(
+            "0xaacFeEa03eb1561C4e67d661e40682Bd20E3541b"
+        )
         self.safe_proxy_factory_abi = _load_abi("SafeProxyFactory")
         self.safe_proxy_factory = self.contract(
             self.safe_proxy_factory_address, self.safe_proxy_factory_abi
@@ -99,6 +111,18 @@ class PolymarketWeb3Client:
                 self.safe_abi = _load_abi("Safe")
                 self.safe = self.contract(self.address, self.safe_abi)
 
+    def _encode_usdc_approve(self, address: ChecksumAddress) -> str:
+        return self.usdc.encode_abi(
+            abi_element_identifier="approve",
+            args=[address, int(MAX_INT, base=16)],
+        )
+
+    def _encode_condition_tokens_approve(self, address: ChecksumAddress) -> str:
+        return self.conditional_tokens.encode_abi(
+            abi_element_identifier="setApprovalForAll",
+            args=[address, True],
+        )
+
     def _encode_split(self, condition_id: Keccak256, amount: int) -> str:
         return self.conditional_tokens.encode_abi(
             abi_element_identifier="splitPosition",
@@ -133,6 +157,139 @@ class PolymarketWeb3Client:
             args=[neg_risk_market_id, index_set, amount],
         )
 
+    def _build_transaction(self) -> TxParams:
+        """Build base transaction parameters."""
+        nonce = self.w3.eth.get_transaction_count(self.account.address)
+
+        current_gas_price: int = self.w3.eth.gas_price
+        adjusted_gas_price = Wei(int(current_gas_price * 1.05))
+
+        transaction: TxParams = {
+            "nonce": nonce,
+            "gasPrice": adjusted_gas_price,
+            "gas": 1000000,
+            "from": self.account.address,
+        }
+
+        return transaction
+
+    def _set_collateral_approval(self, spender: ChecksumAddress) -> str:
+        data = self._encode_usdc_approve(address=spender)
+        transaction = self._build_transaction()
+        txn_data: TxParams | None = None
+
+        match self.signature_type:
+            case 0:
+                txn_data = self.usdc.functions.approve(
+                    spender, int(MAX_INT, base=16)
+                ).build_transaction(transaction=transaction)
+            case 1:
+                proxy_txn = {
+                    "typeCode": 1,
+                    "to": self.usdc_address,
+                    "value": 0,
+                    "data": data,
+                }
+                txn_data = self.proxy_factory.functions.proxy(
+                    [proxy_txn]
+                ).build_transaction(transaction=transaction)
+            case 2:
+                safe_nonce = self.safe.functions.nonce().call()
+                safe_txn = {
+                    "to": self.usdc_address,
+                    "data": data,
+                    "operation": 0,  # 1 for delegatecall, 0 for call
+                    "value": 0,
+                }
+                packed_sig = sign_safe_transaction(
+                    self.account, self.safe, safe_txn, safe_nonce
+                )
+                txn_data = self.safe.functions.execTransaction(
+                    safe_txn["to"],
+                    safe_txn["value"],
+                    safe_txn["data"],
+                    safe_txn.get("operation", 0),
+                    0,  # safeTxGas
+                    0,  # baseGas
+                    0,  # gasPrice
+                    ADDRESS_ZERO,  # gasToken
+                    ADDRESS_ZERO,  # refundReceiver
+                    packed_sig,
+                ).build_transaction(transaction=transaction)
+
+        signed_txn = self.account.sign_transaction(txn_data)
+        tx_hash = self.w3.eth.send_raw_transaction(signed_txn.raw_transaction)
+        tx_hash_hex = tx_hash.hex()
+
+        print(f"Txn hash: 0x{tx_hash_hex}")
+
+        # Wait for transaction to be mined
+        self.w3.eth.wait_for_transaction_receipt(tx_hash)
+
+        print("Done!")
+
+        return f"0x{tx_hash_hex}"
+
+    def _set_conditional_tokens_approval(self, spender: ChecksumAddress) -> str:
+        data = self._encode_condition_tokens_approve(address=spender)
+        transaction = self._build_transaction()
+        txn_data: TxParams | None = None
+
+        match self.signature_type:
+            case 0:
+                txn_data = self.conditional_tokens.functions.setApprovalForAll(
+                    spender, True
+                ).build_transaction(transaction=transaction)
+            case 1:
+                proxy_txn = {
+                    "typeCode": 1,
+                    "to": self.conditional_tokens_address,
+                    "value": 0,
+                    "data": data,
+                }
+                txn_data = self.proxy_factory.functions.proxy(
+                    [proxy_txn]
+                ).build_transaction(transaction=transaction)
+            case 2:
+                safe_nonce = self.safe.functions.nonce().call()
+                safe_txn = {
+                    "to": self.conditional_tokens_address,
+                    "data": data,
+                    "operation": 0,  # 1 for delegatecall, 0 for call
+                    "value": 0,
+                }
+                packed_sig = sign_safe_transaction(
+                    self.account,
+                    self.safe,
+                    safe_txn,
+                    safe_nonce,
+                )
+                txn_data = self.safe.functions.execTransaction(
+                    safe_txn["to"],
+                    safe_txn["value"],
+                    safe_txn["data"],
+                    safe_txn.get("operation", 0),
+                    0,  # safeTxGas
+                    0,  # baseGas
+                    0,  # gasPrice
+                    ADDRESS_ZERO,  # gasToken
+                    ADDRESS_ZERO,  # refundReceiver
+                    packed_sig,
+                ).build_transaction(transaction=transaction)
+
+        signed_txn = self.account.sign_transaction(txn_data)
+        tx_hash = self.w3.eth.send_raw_transaction(signed_txn.raw_transaction)
+        tx_hash_hex = tx_hash.hex()
+
+        print(f"Txn hash: 0x{tx_hash_hex}")
+
+        # Wait for transaction to be mined
+        self.w3.eth.wait_for_transaction_receipt(tx_hash)
+
+        print("Done!")
+
+        return f"0x{tx_hash_hex}"
+
     def contract(self, address, abi):
         return self.w3.eth.contract(
             address=Web3.to_checksum_address(address),
@@ -163,7 +320,7 @@ class PolymarketWeb3Client:
         return float(balance_res / 1e6)
 
     def get_token_balance(
-        self, token_id: str, address: Optional[EthAddress] = None
+        self, token_id: str, address: EthAddress | None = None
     ) -> float:
         """Get the token balance of the given address."""
         if not address:
@@ -173,7 +330,7 @@ class PolymarketWeb3Client:
         ).call()
         return float(balance_res / 1e6)
 
-    def get_token_complement(self, token_id: str) -> Optional[str]:
+    def get_token_complement(self, token_id: str) -> str | None:
         """Get the complement of the given token."""
         try:
             return str(
@@ -191,6 +348,8 @@ class PolymarketWeb3Client:
                         raise ContractCustomError(
                             msg,
                         ) from e2
+                    return None
+            return None
 
     def get_condition_id_neg_risk(self, question_id: Keccak256) -> Keccak256:
         """
@@ -205,9 +364,41 @@ class PolymarketWeb3Client:
             + self.neg_risk_adapter.functions.getConditionId(question_id).call().hex()
         )
 
+    def set_all_approvals(self) -> None:
+        """Sets both collateral and conditional tokens approvals."""
+        print("Approving ConditionalTokens as spender on USDC")
+        self._set_collateral_approval(
+            spender=self.conditional_tokens_address,
+        )
+        print("Approving CTFExchange as spender on USDC")
+        self._set_collateral_approval(
+            spender=self.exchange_address,
+        )
+        print("Approving NegRiskCtfExchange as spender on USDC")
+        self._set_collateral_approval(
+            spender=self.neg_risk_exchange_address,
+        )
+        print("Approving NegRiskAdapter as spender on USDC")
+        self._set_collateral_approval(
+            spender=self.neg_risk_adapter_address,
+        )
+        print("Approving CTFExchange as spender on ConditionalTokens")
+        self._set_conditional_tokens_approval(
+            spender=self.exchange_address,
+        )
+        print("Approving NegRiskCtfExchange as spender on ConditionalTokens")
+        self._set_conditional_tokens_approval(
+            spender=self.neg_risk_exchange_address,
+        )
+        print("Approving NegRiskAdapter as spender on ConditionalTokens")
+        self._set_conditional_tokens_approval(
+            spender=self.neg_risk_adapter_address,
+        )
+        print("All approvals set!")
+
     def split_position(
         self, condition_id: Keccak256, amount: float, neg_risk: bool = True
-    ):
+    ) -> str:
         """Splits usdc into two complementary positions of equal size."""
         amount = int(amount * 1e6)
         data = self._encode_split(condition_id, amount)
@@ -216,13 +407,8 @@ class PolymarketWeb3Client:
             if neg_risk
             else self.conditional_tokens_address
         )
-        nonce = self.w3.eth.get_transaction_count(self.account.address)
-        transaction = {
-            "nonce": nonce,
-            "gasPrice": int(1.05 * self.w3.eth.gas_price),
-            "gas": 1000000,
-            "from": self.account.address,
-        }
+        transaction = self._build_transaction()
+        txn_data: TxParams | None = None
 
         match self.signature_type:
             case 0:
@@ -282,9 +468,11 @@ class PolymarketWeb3Client:
 
         print("Done!")
 
+        return f"0x{tx_hash_hex}"
+
     def merge_position(
         self, condition_id: Keccak256, amount: float, neg_risk: bool = True
-    ):
+    ) -> str:
         """Merges two complementary positions into usdc."""
         amount = int(amount * 1e6)
         data = self._encode_merge(condition_id, amount)
@@ -293,13 +481,8 @@ class PolymarketWeb3Client:
             if neg_risk
             else self.conditional_tokens_address
         )
-        nonce = self.w3.eth.get_transaction_count(self.account.address)
-        transaction = {
-            "nonce": nonce,
-            "gasPrice": int(1.05 * self.w3.eth.gas_price),
-            "gas": 1000000,
-            "from": self.account.address,
-        }
+        transaction = self._build_transaction()
+        txn_data: TxParams | None = None
 
         match self.signature_type:
             case 0:
@@ -360,9 +543,11 @@ class PolymarketWeb3Client:
 
         print("Done!")
 
+        return f"0x{tx_hash_hex}"
+
     def redeem_position(
         self, condition_id: Keccak256, amounts: list[float], neg_risk: bool = True
-    ):
+    ) -> str:
         """
         Redeem a position into usdc.
 
@@ -381,13 +566,8 @@ class PolymarketWeb3Client:
             if neg_risk
             else self.conditional_tokens_address
         )
-        nonce = self.w3.eth.get_transaction_count(self.account.address)
-        transaction = {
-            "nonce": nonce,
-            "gasPrice": int(1.05 * self.w3.eth.gas_price),
-            "gas": 1000000,
-            "from": self.account.address,
-        }
+        transaction = self._build_transaction()
+        txn_data: TxParams | None = None
 
         match self.signature_type:
             case 0:
@@ -451,24 +631,21 @@ class PolymarketWeb3Client:
 
         print("Done!")
 
+        return f"0x{tx_hash_hex}"
+
     def convert_positions(
         self,
         question_ids: list[Keccak256],
         amount: float,
-    ):
+    ) -> str:
         amount = int(amount * 1e6)
         neg_risk_market_id = question_ids[0][:-2] + "00"
         data = self._encode_convert(
             neg_risk_market_id, get_index_set(question_ids), amount
         )
         to = self.neg_risk_adapter_address
-        nonce = self.w3.eth.get_transaction_count(self.account.address)
-        transaction = {
-            "nonce": nonce,
-            "gasPrice": int(1.05 * self.w3.eth.gas_price),
-            "gas": 1000000,
-            "from": self.account.address,
-        }
+        transaction = self._build_transaction()
+        txn_data: TxParams | None = None
 
         match self.signature_type:
             case 0:
@@ -524,3 +701,5 @@ class PolymarketWeb3Client:
         self.w3.eth.wait_for_transaction_receipt(tx_hash)
 
         print("Done!")
+
+        return f"0x{tx_hash_hex}"

polymarket_apis/types/clob_types.py

@@ -221,7 +221,7 @@ class ClobMarket(BaseModel):
     @classmethod
     def validate_neg_risk_fields(
         cls, value: str, handler: ValidatorFunctionWrapHandler, info: ValidationInfo
-    ) -> Optional[str]:
+    ) -> str | None:
         try:
             return handler(value)
         except ValidationError as e:
@@ -238,6 +238,7 @@ class ClobMarket(BaseModel):
                         f" Question: {info.data.get('question')}; Market slug: {info.data.get('market_slug')} \n"
                     )
                     logger.warning(msg)
+            return None
 
     @field_validator("condition_id", "question_id", mode="wrap")
     @classmethod
@@ -323,8 +324,8 @@ class DropNotificationParams(BaseModel):
 
 
 class OrderSummary(BaseModel):
-    price: Optional[float] = None
-    size: Optional[float] = None
+    price: float
+    size: float
 
 
 class PriceLevel(OrderSummary):
@@ -505,7 +506,7 @@ class OrderPostResponse(BaseModel):
     order_id: Union[Keccak256, Literal[""]] = Field(alias="orderID")
     taking_amount: str = Field(alias="takingAmount")
     making_amount: str = Field(alias="makingAmount")
-    status: str = Literal["live", "matched", "delayed"]
+    status: Literal["live", "matched", "delayed"]
     success: bool
 
 

polymarket_apis/types/common.py

@@ -19,7 +19,11 @@ def parse_flexible_datetime(v: str | datetime) -> datetime:
         return datetime.fromtimestamp(0, tz=UTC)
 
     if isinstance(v, str):
-        return parser.parse(v)
+        parsed = parser.parse(v)
+        if not isinstance(parsed, datetime):
+            msg = f"Failed to parse '{v}' as datetime, got {type(parsed)}"
+            raise TypeError(msg)
+        return parsed
     return v
 
 

polymarket_apis/utilities/constants.py

@@ -1,3 +1,5 @@
+from typing import Literal
+
 # Access levels
 L0 = 0
 L1 = 1
@@ -17,9 +19,8 @@ L2_AUTH_UNAVAILABLE = "API Credentials are needed to interact with this endpoint
 ADDRESS_ZERO = "0x0000000000000000000000000000000000000000"
 HASH_ZERO = "0x0000000000000000000000000000000000000000000000000000000000000000"
 
-AMOY = 80002
-POLYGON = 137
-
+AMOY: Literal[80002] = 80002
+POLYGON: Literal[137] = 137
 END_CURSOR = "LTE="
 
 BUY = "BUY"

polymarket_apis/utilities/order_builder/builder.py

@@ -221,10 +221,10 @@ class OrderBuilder:
             msg = "No ask orders available"
             raise LiquidityError(msg)
 
-        sum = 0
+        amount = 0.0
         for p in reversed(asks):
-            sum += float(p.size) * float(p.price)
-            if sum >= amount_to_match:
+            amount += float(p.size) * float(p.price)
+            if amount >= amount_to_match:
                 return float(p.price)
 
         if order_type == OrderType.FOK:
@@ -245,10 +245,10 @@ class OrderBuilder:
             msg = "No bid orders available"
             raise LiquidityError(msg)
 
-        sum = 0
+        amount = 0.0
         for p in reversed(bids):
-            sum += float(p.size)
-            if sum >= amount_to_match:
+            amount += float(p.size)
+            if amount >= amount_to_match:
                 return float(p.price)
 
         if order_type == OrderType.FOK:

polymarket_apis/utilities/signing/signer.py

@@ -11,7 +11,7 @@ class Signer:
             raise ValueError(msg)
 
         self.private_key = private_key
-        self.account = Account.from_key(private_key)
+        self.account = Account.from_key(private_key)  # type: ignore[misc]
         self.chain_id = chain_id
 
     def address(self):
@@ -22,4 +22,4 @@ class Signer:
 
     def sign(self, message_hash):
         """Signs a message hash."""
-        return Account.unsafe_sign_hash(message_hash, self.private_key).signature.hex()
+        return Account.unsafe_sign_hash(message_hash, self.private_key).signature.hex()  # type: ignore[misc]

{polymarket_apis-0.3.6.dist-info → polymarket_apis-0.3.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polymarket-apis
-Version: 0.3.6
+Version: 0.3.7
 Summary: Unified Polymarket APIs with Pydantic data validation - Clob, Gamma, Data, Web3, Websockets, GraphQL clients.
 Project-URL: repository, https://github.com/qualiaenjoyer/polymarket-apis
 Author-email: Razvan Gheorghe <razvan@gheorghe.me>
@@ -155,7 +155,10 @@ flowchart LR
     - get top users on the profit/volume leaderboards (at most 100) for a recent window (1d, 7d, 30d, all)
 
   ### PolymarketWeb3Client - Blockchain related operations
-  - #### Supporting both Email/Magic wallets (signature_type=1) and Safe/Gnosis wallets (signature_type=2)
+  - #### Supporting EOA(signature_type=0), Email/Magic wallets (signature_type=1) and Safe/Gnosis wallets (signature_type=2)
+  - #### Approvals
+    - set approvals for all needed usdc and conditional token spenders (needed for full trading functionality)
+      - Safe/Gnosis wallets need to be deployed beforehand, either via "Enable Trading" pop-up on the web UI or by calling createProxy on the SafeWalletFactory contract (wip)
   - #### Balance
     - get usdc balance by user address
     - get token balance by `token_id` and user address

{polymarket_apis-0.3.6.dist-info → polymarket_apis-0.3.7.dist-info}/RECORD

@@ -1,31 +1,31 @@
-polymarket_apis/__init__.py,sha256=qovYOBPNsQVc792R8UIVlGIrU-p-2DKclTosLQZbhT4,1126
+polymarket_apis/__init__.py,sha256=OzhWc-PqnHoGyrcRwclQG2mLGSu0cz7QLuhx-jenzgk,1126
 polymarket_apis/clients/__init__.py,sha256=ruMvFEA4HNkbWEYqbnrCuYXR4PUwkV1XWG0w63we-LA,759
-polymarket_apis/clients/clob_client.py,sha256=gt3EqqMYOYB0_hI8HByp0flfKRsUkzL9gpQZJxX_r5k,32359
-polymarket_apis/clients/data_client.py,sha256=xHZcjZMKpzPD8kipPc1qN08q7jWPqN3Py1hD28MQ2EQ,13151
-polymarket_apis/clients/gamma_client.py,sha256=tBR_z03c3wh1_sxFbjNx54DcrFEjFB0TmJiOYNUc_pk,27632
+polymarket_apis/clients/clob_client.py,sha256=Eo5zXYtI_Ct0EByzjJnH6h7FLHOqheXDujBA57CtINw,32485
+polymarket_apis/clients/data_client.py,sha256=0--2W6_DZtC7cRud8OYS7bH2heWzn2NwvcUVK3PyEwU,13242
+polymarket_apis/clients/gamma_client.py,sha256=iDfuaClhRK2Y5v8ZA03Qbne3CnIM4JJolHo-qUrQV78,27633
 polymarket_apis/clients/graphql_client.py,sha256=KgjxbXNWEXp82ZEz464in5mCn1PydnZqWq-g11xu9YU,1839
-polymarket_apis/clients/web3_client.py,sha256=KR48E9rVKfwqo6BCtGKQZ6VYyeRTiKPKMlI3sv0gjpk,19843
+polymarket_apis/clients/web3_client.py,sha256=Xsk1APsnMDRu9daLKZnf6LW41LdocuRV9rqjKnZjYmw,26400
 polymarket_apis/clients/websockets_client.py,sha256=gaGcsjqp1ZRyxrL6EWvZ9XaTv7koTPDzlcShj0u0B2A,7737
 polymarket_apis/types/__init__.py,sha256=cyrAPNX0ty0wkMwZqB0lNA7n3JoOJCSeTpclmamMh9k,3258
-polymarket_apis/types/clob_types.py,sha256=PmD_afx7zowX0cFJ39PQQ4jywGtwNjLfoke1H7iZZnI,11744
-polymarket_apis/types/common.py,sha256=zFo10eBj4_3alOhYSilCm6Dh5ZkzhrdR9nuRSDQ_od8,1107
+polymarket_apis/types/clob_types.py,sha256=WZs370ni2B2UsLW-yIPGA2C-z8dfbywX26vADuu2YFc,11725
+polymarket_apis/types/common.py,sha256=OYvn-BIbLM5YHNiZCi9ttqbqfPjRdvFhBE192EsBIdQ,1284
 polymarket_apis/types/data_types.py,sha256=vBElvARw8LkH2xXwJkVErpQo0FkXJA3b44hKD5clSOI,5729
 polymarket_apis/types/gamma_types.py,sha256=MoIUI6csqEp_vij7mkFi2IlIA99c5UNzI3zODSONWzQ,30641
 polymarket_apis/types/websockets_types.py,sha256=XGTpfix2rFFQg-97ZkPagS_tHJJpSnB5mCMf_sT2MOI,11180
 polymarket_apis/utilities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 polymarket_apis/utilities/config.py,sha256=kQymQRy9fVg5jt8CcQJxsSgIZFbfjPx2q_gNnZI5b24,2449
-polymarket_apis/utilities/constants.py,sha256=rGX-XXu5tLy2yUurFQCQNRtSvZPPcRAUCmjlqVtTAvY,580
+polymarket_apis/utilities/constants.py,sha256=TzFVtN8zNgvEa4yjLWjpvPYsAi1LLV5oPEnHlbwxSDQ,637
 polymarket_apis/utilities/endpoints.py,sha256=bxZyrJBPbVauWc-eR0RMh6KDqU-SmO_3LfQwVMNJ6vE,1235
 polymarket_apis/utilities/exceptions.py,sha256=nLVkwGNkX8mBhOi3L3lLEJ5UCPd5OBjl2f7kcct3K3A,368
 polymarket_apis/utilities/headers.py,sha256=Cc5WEnIBLYAgfwvmCXRBwA2zUYME8fDy4PbwlwlB6Oo,1510
 polymarket_apis/utilities/order_builder/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-polymarket_apis/utilities/order_builder/builder.py,sha256=1SXgJlKlutRqMA1iBtZcw5K6CWI379d4wXZ5pdNgs0M,8454
+polymarket_apis/utilities/order_builder/builder.py,sha256=dyxKhMeNjGyHXEIFBBZhWwI8TaQQcE_ErQ4sF6BcMX0,8476
 polymarket_apis/utilities/order_builder/helpers.py,sha256=2-UYDLntYOXjyN0ZDQI13jW2zwXwIODEK-smBRFTYRk,1943
 polymarket_apis/utilities/signing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 polymarket_apis/utilities/signing/eip712.py,sha256=fGLurznnfY5M0VCP1Txyq_FYQRfggyHoTwz-PGIK2Eg,895
 polymarket_apis/utilities/signing/hmac.py,sha256=1VPfO2yT8nyStk6U4AQeyTzQTt5-69PTw24Gdt5YOMo,718
 polymarket_apis/utilities/signing/model.py,sha256=kVduuJGth7WSCUDCVVydCgPd4yEVI85gEmMxohXsvp0,191
-polymarket_apis/utilities/signing/signer.py,sha256=7-nFALFrz0qg4F4lZRyHI41S7IWxr7t0WMLOHqHzJcg,732
+polymarket_apis/utilities/signing/signer.py,sha256=cxjcYRn1a0ApVcir1AvamsFcLZ0rYNlEEX4sPUz_Nrw,776
 polymarket_apis/utilities/web3/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 polymarket_apis/utilities/web3/helpers.py,sha256=qzQA-n9rHbuFk57olvBa8P_T6IzrUsaQ2Vv0887EX4o,4694
 polymarket_apis/utilities/web3/abis/CTFExchange.json,sha256=zt8fZnUaOrD8Vh5njM0EEUpeITWhuu0SZrIZigWxgV8,38499
@@ -38,6 +38,6 @@ polymarket_apis/utilities/web3/abis/SafeProxyFactory.json,sha256=bdr2WdYCRClXLTT
 polymarket_apis/utilities/web3/abis/UChildERC20Proxy.json,sha256=ZyQC38U0uxInlmnW2VXDVD3TJfTIRmSNMkTxQsaG7oA,27396
 polymarket_apis/utilities/web3/abis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 polymarket_apis/utilities/web3/abis/custom_contract_errors.py,sha256=GjCVn2b6iRheT7s-kc8Po9uwH9LfaHA1yRpJyjXRcxs,1172
-polymarket_apis-0.3.6.dist-info/METADATA,sha256=AToVPj7UlKers6vyyeIFBjgNvdridWvI7Y82_T8fHzg,12479
-polymarket_apis-0.3.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-polymarket_apis-0.3.6.dist-info/RECORD,,
+polymarket_apis-0.3.7.dist-info/METADATA,sha256=Z3jOxzSY7thon83qiZQbeZ_8sCebx2BKCVRKR-acFjA,12802
+polymarket_apis-0.3.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+polymarket_apis-0.3.7.dist-info/RECORD,,