polymarket-apis 0.3.2__py3-none-any.whl → 0.3.3__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.2"
+__version__ = "0.3.3"
 __author__ = "Razvan Gheorghe"
 __email__ = "razvan@gheorghe.me"
 
@@ -23,12 +23,13 @@ from .clients import (
     PolymarketWeb3Client,
     PolymarketWebsocketsClient,
 )
-from .types.clob_types import MarketOrderArgs, OrderArgs
+from .types.clob_types import MarketOrderArgs, OrderArgs, OrderType
 
 __all__ = [
     "AsyncPolymarketGraphQLClient",
     "MarketOrderArgs",
     "OrderArgs",
+    "OrderType",
     "PolymarketClobClient",
     "PolymarketDataClient",
     "PolymarketGammaClient",

polymarket_apis/clients/gamma_client.py

@@ -551,7 +551,9 @@ class PolymarketGammaClient:
             params["omit_empty"] = str(omit_empty).lower()
         if status:
             params["status"] = status
-        response = self.client.get(self._build_url(f"/tags/{tag_id}/related-tags"), params=params)
+        response = self.client.get(
+            self._build_url(f"/tags/{tag_id}/related-tags"), params=params
+        )
         response.raise_for_status()
         return [TagRelation(**tag) for tag in response.json()]
 
@@ -566,7 +568,9 @@ class PolymarketGammaClient:
             params["omit_empty"] = str(omit_empty).lower()
         if status:
             params["status"] = status
-        response = self.client.get(self._build_url(f"/tags/slug/{slug}/related-tags"), params=params)
+        response = self.client.get(
+            self._build_url(f"/tags/slug/{slug}/related-tags"), params=params
+        )
         response.raise_for_status()
         return [TagRelation(**tag) for tag in response.json()]
 
@@ -581,7 +585,9 @@ class PolymarketGammaClient:
             params["omit_empty"] = str(omit_empty).lower()
         if status:
             params["status"] = status
-        response = self.client.get(self._build_url(f"/tags/{tag_id}/related-tags/tags"), params=params)
+        response = self.client.get(
+            self._build_url(f"/tags/{tag_id}/related-tags/tags"), params=params
+        )
         response.raise_for_status()
         return [Tag(**tag) for tag in response.json()]
 

polymarket_apis/clients/web3_client.py

@@ -8,9 +8,12 @@ from web3.middleware import ExtraDataToPOAMiddleware, SignAndSendRawMiddlewareBu
 
 from ..types.common import EthAddress, Keccak256
 from ..utilities.config import get_contract_config
-from ..utilities.constants import HASH_ZERO, POLYGON
+from ..utilities.constants import ADDRESS_ZERO, HASH_ZERO, POLYGON
 from ..utilities.web3.abis.custom_contract_errors import CUSTOM_ERROR_DICT
-from ..utilities.web3.helpers import get_index_set
+from ..utilities.web3.helpers import (
+    get_index_set,
+    sign_safe_transaction,
+)
 
 
 def _load_abi(contract_name: str) -> list:
@@ -26,7 +29,12 @@ def _load_abi(contract_name: str) -> list:
 
 
 class PolymarketWeb3Client:
-    def __init__(self, private_key: str, chain_id: Literal[137, 80002] = POLYGON):
+    def __init__(
+        self,
+        private_key: str,
+        signature_type: Literal[1, 2] = 1,
+        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(
@@ -34,6 +42,7 @@ class PolymarketWeb3Client:
         )
 
         self.account = self.w3.eth.account.from_key(private_key)
+        self.signature_type = signature_type
 
         self.config = get_contract_config(chain_id, neg_risk=False)
         self.neg_risk_config = get_contract_config(chain_id, neg_risk=True)
@@ -74,6 +83,23 @@ class PolymarketWeb3Client:
             self.proxy_factory_address, self.proxy_factory_abi
         )
 
+        self.safe_proxy_factory_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
+        )
+
+        match self.signature_type:
+            case 1:
+                self.proxy_address = self.get_poly_proxy_address()
+            case 2:
+                self.proxy_address = self.get_safe_proxy_address()
+                self.safe_abi = _load_abi("Safe")
+                self.safe = self.contract(self.proxy_address, self.safe_abi)
+            case _:
+                msg = "Invalid signature_type: choose 1 for Magic/Email wallet or 2 for Safe/Gnosis wallet"
+                raise ValueError(msg)
+
     def _encode_split(self, condition_id: Keccak256, amount: int) -> str:
         return self.conditional_tokens.encode_abi(
             abi_element_identifier="splitPosition",
@@ -114,6 +140,16 @@ class PolymarketWeb3Client:
             abi=abi,
         )
 
+    def get_poly_proxy_address(self, address: EthAddress | None = None) -> EthAddress:
+        """Get the polymarket proxy address for the current account."""
+        address = address if address else self.account.address
+        return self.exchange.functions.getPolyProxyWalletAddress(address).call()
+
+    def get_safe_proxy_address(self, address: EthAddress | None = None) -> EthAddress:
+        """Get the safe proxy address for the current account."""
+        address = address if address else self.account.address
+        return self.safe_proxy_factory.functions.computeProxyAddress(address).call()
+
     def get_usdc_balance(self, address: EthAddress | None = None) -> float:
         """
         Get the usdc balance of the given address.
@@ -123,9 +159,7 @@ class PolymarketWeb3Client:
         Explicitly passing the proxy address is faster due to only one contract function call.
         """
         if address is None:
-            address = self.exchange.functions.getPolyProxyWalletAddress(
-                self.account.address
-            ).call()
+            address = self.get_poly_proxy_address()
         balance_res = self.usdc.functions.balanceOf(address).call()
         return float(balance_res / 1e6)
 
@@ -133,10 +167,15 @@ class PolymarketWeb3Client:
         self, token_id: str, address: EthAddress | None = None
     ) -> float:
         """Get the token balance of the given address."""
-        if address is None:
-            address = self.exchange.functions.getPolyProxyWalletAddress(
-                self.account.address
-            ).call()
+        if not address:
+            match self.signature_type:
+                case 1:
+                    address = self.get_poly_proxy_address(self.account.address)
+                case 2:
+                    address = self.get_safe_proxy_address(self.account.address)
+                case _:
+                    msg = "Invalid signature_type: choose 1 for Magic/Email wallet or 2 for Safe/Gnosis wallet"
+                    raise ValueError(msg)
         balance_res = self.conditional_tokens.functions.balanceOf(
             address, int(token_id)
         ).call()
@@ -178,34 +217,75 @@ class PolymarketWeb3Client:
         self, condition_id: Keccak256, amount: int, neg_risk: bool = True
     ):
         """Splits usdc into two complementary positions of equal size."""
-        nonce = self.w3.eth.get_transaction_count(self.account.address)
         amount = int(amount * 1e6)
-
-        proxy_txn = {
-            "typeCode": 1,
-            "to": self.neg_risk_adapter_address
+        data = self._encode_split(condition_id, amount)
+        to = (
+            self.neg_risk_adapter_address
             if neg_risk
-            else self.conditional_tokens_address,
-            "value": 0,
-            "data": self._encode_split(condition_id, amount),
-        }
-
-        # Send transaction through proxy factory
-        txn_data = self.proxy_factory.functions.proxy([proxy_txn]).build_transaction(
-            {
-                "nonce": nonce,
-                "gasPrice": int(1.05 * self.w3.eth.gas_price),
-                "gas": 1000000,
-                "from": self.account.address,
-            }
+            else self.conditional_tokens_address
         )
 
+        match self.signature_type:
+            case 1:
+                nonce = self.w3.eth.get_transaction_count(self.account.address)
+                proxy_txn = {
+                    "typeCode": 1,
+                    "to": to,
+                    "value": 0,
+                    "data": data,
+                }
+
+                txn_data = self.proxy_factory.functions.proxy(
+                    [proxy_txn]
+                ).build_transaction(
+                    {
+                        "nonce": nonce,
+                        "gasPrice": int(1.05 * self.w3.eth.gas_price),
+                        "gas": 1000000,
+                        "from": self.account.address,
+                    }
+                )
+            case 2:
+                nonce = self.safe.functions.nonce().call()
+                safe_txn = {
+                    "to": to,
+                    "data": data,
+                    "operation": 0,  # 1 for delegatecall, 0 for call
+                    "value": 0,
+                }
+
+                packed_sig = sign_safe_transaction(
+                    self.account, self.safe, safe_txn, 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(
+                    {
+                        "nonce": self.w3.eth.get_transaction_count(
+                            self.account.address
+                        ),
+                        "gasPrice": int(1.05 * self.w3.eth.gas_price),
+                        "gas": 1000000,
+                        "from": self.account.address,
+                    }
+                )
+
         # Sign and send 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: {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)
@@ -216,34 +296,74 @@ class PolymarketWeb3Client:
         self, condition_id: Keccak256, amount: int, neg_risk: bool = True
     ):
         """Merges two complementary positions into usdc."""
-        nonce = self.w3.eth.get_transaction_count(self.account.address)
         amount = int(amount * 1e6)
-
-        proxy_txn = {
-            "typeCode": 1,
-            "to": self.neg_risk_adapter_address
+        data = self._encode_merge(condition_id, amount)
+        to = (
+            self.neg_risk_adapter_address
             if neg_risk
-            else self.conditional_tokens_address,
-            "value": 0,
-            "data": self._encode_merge(condition_id, amount),
-        }
-
-        # Send transaction through proxy factory
-        txn_data = self.proxy_factory.functions.proxy([proxy_txn]).build_transaction(
-            {
-                "nonce": nonce,
-                "gasPrice": int(1.05 * self.w3.eth.gas_price),
-                "gas": 1000000,
-                "from": self.account.address,
-            }
+            else self.conditional_tokens_address
         )
 
+        match self.signature_type:
+            case 1:
+                nonce = self.w3.eth.get_transaction_count(self.account.address)
+                proxy_txn = {
+                    "typeCode": 1,
+                    "to": to,
+                    "value": 0,
+                    "data": data,
+                }
+
+                txn_data = self.proxy_factory.functions.proxy(
+                    [proxy_txn]
+                ).build_transaction(
+                    {
+                        "nonce": nonce,
+                        "gasPrice": int(1.05 * self.w3.eth.gas_price),
+                        "gas": 1000000,
+                        "from": self.account.address,
+                    }
+                )
+            case 2:
+                nonce = self.safe.functions.nonce().call()
+                safe_txn = {
+                    "to": to,
+                    "data": data,
+                    "operation": 0,  # 1 for delegatecall, 0 for call
+                    "value": 0,
+                }
+
+                packed_sig = sign_safe_transaction(
+                    self.account, self.safe, safe_txn, 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(
+                    {
+                        "nonce": self.w3.eth.get_transaction_count(
+                            self.account.address
+                        ),
+                        "gasPrice": int(1.05 * self.w3.eth.gas_price),
+                        "gas": 1000000,
+                        "from": self.account.address,
+                    }
+                )
+
         # Sign and send 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: {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)
@@ -260,36 +380,78 @@ class PolymarketWeb3Client:
         where x is the number of shares of the first outcome
               y is the number of shares of the second outcome.
         """
-        nonce = self.w3.eth.get_transaction_count(self.account.address)
         amounts = [int(amount * 1e6) for amount in amounts]
-
-        proxy_txn = {
-            "typeCode": 1,
-            "to": self.neg_risk_adapter_address
+        data = (
+            self._encode_redeem_neg_risk(condition_id, amounts)
             if neg_risk
-            else self.conditional_tokens_address,
-            "value": 0,
-            "data": self._encode_redeem_neg_risk(condition_id, amounts)
+            else self._encode_redeem(condition_id)
+        )
+        to = (
+            self.neg_risk_adapter_address
             if neg_risk
-            else self._encode_redeem(condition_id),
-        }
-
-        # Send transaction through proxy factory
-        txn_data = self.proxy_factory.functions.proxy([proxy_txn]).build_transaction(
-            {
-                "nonce": nonce,
-                "gasPrice": int(1.05 * self.w3.eth.gas_price),
-                "gas": 1000000,
-                "from": self.account.address,
-            }
+            else self.conditional_tokens_address
         )
 
+        match self.signature_type:
+            case 1:
+                nonce = self.w3.eth.get_transaction_count(self.account.address)
+                proxy_txn = {
+                    "typeCode": 1,
+                    "to": to,
+                    "value": 0,
+                    "data": data,
+                }
+
+                txn_data = self.proxy_factory.functions.proxy(
+                    [proxy_txn]
+                ).build_transaction(
+                    {
+                        "nonce": nonce,
+                        "gasPrice": int(1.05 * self.w3.eth.gas_price),
+                        "gas": 1000000,
+                        "from": self.account.address,
+                    }
+                )
+            case 2:
+                nonce = self.safe.functions.nonce().call()
+                safe_txn = {
+                    "to": to,
+                    "data": data,
+                    "operation": 0,  # 1 for delegatecall, 0 for call
+                    "value": 0,
+                }
+
+                packed_sig = sign_safe_transaction(
+                    self.account, self.safe, safe_txn, 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(
+                    {
+                        "nonce": self.w3.eth.get_transaction_count(
+                            self.account.address
+                        ),
+                        "gasPrice": int(1.05 * self.w3.eth.gas_price),
+                        "gas": 1000000,
+                        "from": self.account.address,
+                    }
+                )
+
         # Sign and send 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: {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)
@@ -301,31 +463,71 @@ class PolymarketWeb3Client:
     ):
         nonce = self.w3.eth.get_transaction_count(self.account.address)
         amount = int(amount * 1e6)
-
-        proxy_txn = {
-            "typeCode": 1,
-            "to": self.neg_risk_adapter_address,
-            "value": 0,
-            "data": self._encode_convert(
-                neg_risk_market_id, get_index_set(question_ids), amount
-            ),
-        }
-
-        txn_data = self.proxy_factory.functions.proxy([proxy_txn]).build_transaction(
-            {
-                "nonce": nonce,
-                "gasPrice": int(1.05 * self.w3.eth.gas_price),
-                "gas": 1000000,
-                "from": self.account.address,
-            }
+        data = self._encode_convert(
+            neg_risk_market_id, get_index_set(question_ids), amount
         )
+        to = self.neg_risk_adapter_address
+
+        match self.signature_type:
+            case 1:
+                nonce = self.w3.eth.get_transaction_count(self.account.address)
+                proxy_txn = {
+                    "typeCode": 1,
+                    "to": to,
+                    "value": 0,
+                    "data": data,
+                }
+
+                txn_data = self.proxy_factory.functions.proxy(
+                    [proxy_txn]
+                ).build_transaction(
+                    {
+                        "nonce": nonce,
+                        "gasPrice": int(1.05 * self.w3.eth.gas_price),
+                        "gas": 1000000,
+                        "from": self.account.address,
+                    }
+                )
+            case 2:
+                nonce = self.safe.functions.nonce().call()
+                safe_txn = {
+                    "to": to,
+                    "data": data,
+                    "operation": 0,  # 1 for delegatecall, 0 for call
+                    "value": 0,
+                }
+
+                packed_sig = sign_safe_transaction(
+                    self.account, self.safe, safe_txn, 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(
+                    {
+                        "nonce": self.w3.eth.get_transaction_count(
+                            self.account.address
+                        ),
+                        "gasPrice": int(1.05 * self.w3.eth.gas_price),
+                        "gas": 1000000,
+                        "from": self.account.address,
+                    }
+                )
 
         # Sign and send 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: {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)

polymarket_apis/types/clob_types.py

@@ -17,7 +17,7 @@ from pydantic import (
 )
 
 from ..types.common import EthAddress, Keccak256, TimeseriesPoint
-from ..utilities.constants import ZERO_ADDRESS
+from ..utilities.constants import ADDRESS_ZERO
 
 logger = logging.getLogger(__name__)
 
@@ -428,7 +428,7 @@ class OrderArgs(BaseModel):
     Timestamp after which the order is expired.
     """
 
-    taker: str = ZERO_ADDRESS
+    taker: str = ADDRESS_ZERO
     """
     Address of the order taker. The zero address is used to indicate a public order.
     """
@@ -466,7 +466,7 @@ class MarketOrderArgs(BaseModel):
     Nonce used for onchain cancellations.
     """
 
-    taker: str = ZERO_ADDRESS
+    taker: str = ADDRESS_ZERO
     """
     Address of the order taker. The zero address is used to indicate a public order.
     """

polymarket_apis/types/gamma_types.py

@@ -189,6 +189,14 @@ class GammaMarket(BaseModel):
     rfq_enabled: Optional[bool] = Field(None, alias="rfqEnabled")
     event_start_time: Optional[datetime] = Field(None, alias="eventStartTime")
     clob_rewards: Optional[list[ClobReward]] = Field(None, alias="clobRewards")
+    submitted_by: Optional[str] = None
+    approved: Optional[bool] = None
+    pager_duty_notification_enabled: Optional[bool] = Field(
+        None, alias="pagerDutyNotificationEnabled"
+    )
+    holding_rewards_enabled: Optional[bool] = Field(None, alias="holdingRewardsEnabled")
+    fees_enabled: Optional[bool] = Field(None, alias="feesEnabled")
+    cyom: Optional[bool] = Field(None, alias="cyom")
 
     @field_validator("condition_id", mode="wrap")
     @classmethod
@@ -487,6 +495,7 @@ class Event(BaseModel):
     liquidity_amm: Optional[float] = Field(None, alias="liquidityAmm")
     liquidity_clob: Optional[float] = Field(None, alias="liquidityClob")
     neg_risk: Optional[bool] = Field(None, alias="negRisk")
+    neg_risk_augmented: Optional[bool] = Field(None, alias="negRiskAugmented")
     neg_risk_market_id: Optional[str] = Field(None, alias="negRiskMarketID")
     neg_risk_fee_bips: Optional[int] = Field(None, alias="negRiskFeeBips")
     comment_count: Optional[int] = Field(None, alias="commentCount")

polymarket_apis/utilities/constants.py

@@ -14,7 +14,7 @@ L1_AUTH_UNAVAILABLE = "A private key is needed to interact with this endpoint!"
 
 L2_AUTH_UNAVAILABLE = "API Credentials are needed to interact with this endpoint!"
 
-ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"
+ADDRESS_ZERO = "0x0000000000000000000000000000000000000000"
 HASH_ZERO = "0x0000000000000000000000000000000000000000000000000000000000000000"
 
 AMOY = 80002