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

prediction_market_agent_tooling/markets/omen/omen_contracts.py

@@ -5,7 +5,6 @@ from datetime import timedelta
 from enum import Enum
 
 from web3 import Web3
-from web3.constants import HASH_ZERO
 
 from prediction_market_agent_tooling.config import APIKeys
 from prediction_market_agent_tooling.gtypes import (
@@ -13,7 +12,6 @@ from prediction_market_agent_tooling.gtypes import (
     ChecksumAddress,
     HexAddress,
     HexBytes,
-    HexStr,
     IPFSCIDVersion0,
     OutcomeWei,
     TxParams,
@@ -24,11 +22,9 @@ from prediction_market_agent_tooling.gtypes import (
 )
 from prediction_market_agent_tooling.markets.omen.data_models import (
     INVALID_ANSWER_HEX_BYTES,
-    ConditionPreparationEvent,
     ContractPrediction,
     FPMMFundingAddedEvent,
     OmenFixedProductMarketMakerCreationEvent,
-    PayoutRedemptionEvent,
     RealitioLogNewQuestionEvent,
     format_realitio_question,
 )
@@ -38,6 +34,7 @@ from prediction_market_agent_tooling.markets.omen.omen_constants import (
     WRAPPED_XDAI_CONTRACT_ADDRESS,
 )
 from prediction_market_agent_tooling.tools.contract import (
+    ConditionalTokenContract,
     ContractDepositableWrapperERC20OnGnosisChain,
     ContractERC20OnGnosisChain,
     ContractERC4626OnGnosisChain,
@@ -96,202 +93,11 @@ class OmenOracleContract(ContractOnGnosisChain):
         )
 
 
-def build_parent_collection_id() -> HexStr:
-    return HASH_ZERO  # Taken from Olas
-
-
-class OmenConditionalTokenContract(ContractOnGnosisChain):
-    # Contract ABI taken from https://gnosisscan.io/address/0xCeAfDD6bc0bEF976fdCd1112955828E00543c0Ce#code.
-    abi: ABI = abi_field_validator(
-        os.path.join(
-            os.path.dirname(os.path.realpath(__file__)),
-            "../../abis/omen_fpmm_conditionaltokens.abi.json",
-        )
-    )
+class OmenConditionalTokenContract(ConditionalTokenContract, ContractOnGnosisChain):
     address: ChecksumAddress = Web3.to_checksum_address(
         "0xCeAfDD6bc0bEF976fdCd1112955828E00543c0Ce"
     )
 
-    def getConditionId(
-        self,
-        question_id: HexBytes,
-        oracle_address: ChecksumAddress,
-        outcomes_slot_count: int,
-        web3: Web3 | None = None,
-    ) -> HexBytes:
-        id_ = HexBytes(
-            self.call(
-                "getConditionId",
-                [oracle_address, question_id, outcomes_slot_count],
-                web3=web3,
-            )
-        )
-        return id_
-
-    def balanceOf(
-        self, from_address: ChecksumAddress, position_id: int, web3: Web3 | None = None
-    ) -> OutcomeWei:
-        balance = OutcomeWei(
-            self.call("balanceOf", [from_address, position_id], web3=web3)
-        )
-        return balance
-
-    def getCollectionId(
-        self,
-        parent_collection_id: HexStr,
-        condition_id: HexBytes,
-        index_set: int,
-        web3: Web3 | None = None,
-    ) -> HexBytes:
-        collection_id = HexBytes(
-            self.call(
-                "getCollectionId",
-                [parent_collection_id, condition_id, index_set],
-                web3=web3,
-            )
-        )
-        return collection_id
-
-    def getPositionId(
-        self,
-        collateral_token_address: ChecksumAddress,
-        collection_id: HexBytes,
-        web3: Web3 | None = None,
-    ) -> int:
-        position_id: int = self.call(
-            "getPositionId",
-            [collateral_token_address, collection_id],
-            web3=web3,
-        )
-        return position_id
-
-    def mergePositions(
-        self,
-        api_keys: APIKeys,
-        collateral_token_address: ChecksumAddress,
-        conditionId: HexBytes,
-        index_sets: t.List[int],
-        amount: OutcomeWei,
-        parent_collection_id: HexStr = build_parent_collection_id(),
-        web3: Web3 | None = None,
-    ) -> TxReceipt:
-        return self.send(
-            api_keys=api_keys,
-            function_name="mergePositions",
-            function_params=[
-                collateral_token_address,
-                parent_collection_id,
-                conditionId,
-                index_sets,
-                amount,
-            ],
-            web3=web3,
-        )
-
-    def redeemPositions(
-        self,
-        api_keys: APIKeys,
-        collateral_token_address: HexAddress,
-        condition_id: HexBytes,
-        index_sets: t.List[int],
-        parent_collection_id: HexStr = build_parent_collection_id(),
-        web3: Web3 | None = None,
-    ) -> PayoutRedemptionEvent:
-        receipt_tx = self.send(
-            api_keys=api_keys,
-            function_name="redeemPositions",
-            function_params=[
-                collateral_token_address,
-                parent_collection_id,
-                condition_id,
-                index_sets,
-            ],
-            web3=web3,
-        )
-        redeem_event_logs = (
-            self.get_web3_contract(web3=web3)
-            .events.PayoutRedemption()
-            .process_receipt(receipt_tx)
-        )
-        redeem_event = PayoutRedemptionEvent(**redeem_event_logs[0]["args"])
-        return redeem_event
-
-    def getOutcomeSlotCount(
-        self, condition_id: HexBytes, web3: Web3 | None = None
-    ) -> int:
-        count: int = self.call("getOutcomeSlotCount", [condition_id], web3=web3)
-        return count
-
-    def does_condition_exists(
-        self, condition_id: HexBytes, web3: Web3 | None = None
-    ) -> bool:
-        return self.getOutcomeSlotCount(condition_id, web3=web3) > 0
-
-    def is_condition_resolved(
-        self, condition_id: HexBytes, web3: Web3 | None = None
-    ) -> bool:
-        # from ConditionalTokens.redeemPositions:
-        # uint den = payoutDenominator[conditionId]; require(den > 0, "result for condition not received yet");
-        payout_for_condition = self.payoutDenominator(condition_id, web3=web3)
-        return payout_for_condition > 0
-
-    def payoutDenominator(
-        self, condition_id: HexBytes, web3: Web3 | None = None
-    ) -> int:
-        payoutForCondition: int = self.call(
-            "payoutDenominator", [condition_id], web3=web3
-        )
-        return payoutForCondition
-
-    def setApprovalForAll(
-        self,
-        api_keys: APIKeys,
-        for_address: ChecksumAddress,
-        approve: bool,
-        tx_params: t.Optional[TxParams] = None,
-        web3: Web3 | None = None,
-    ) -> TxReceipt:
-        return self.send(
-            api_keys=api_keys,
-            function_name="setApprovalForAll",
-            function_params=[
-                for_address,
-                approve,
-            ],
-            tx_params=tx_params,
-            web3=web3,
-        )
-
-    def prepareCondition(
-        self,
-        api_keys: APIKeys,
-        oracle_address: ChecksumAddress,
-        question_id: HexBytes,
-        outcomes_slot_count: int,
-        tx_params: t.Optional[TxParams] = None,
-        web3: Web3 | None = None,
-    ) -> ConditionPreparationEvent:
-        receipt_tx = self.send(
-            api_keys=api_keys,
-            function_name="prepareCondition",
-            function_params=[
-                oracle_address,
-                question_id,
-                outcomes_slot_count,
-            ],
-            tx_params=tx_params,
-            web3=web3,
-        )
-
-        event_logs = (
-            self.get_web3_contract(web3=web3)
-            .events.ConditionPreparation()
-            .process_receipt(receipt_tx)
-        )
-        cond_event = ConditionPreparationEvent(**event_logs[0]["args"])
-
-        return cond_event
-
 
 class OmenFixedProductMarketMakerContract(ContractOnGnosisChain):
     # File content taken from https://github.com/protofire/omen-exchange/blob/master/app/src/abi/marketMaker.json.

prediction_market_agent_tooling/markets/omen/omen_resolving.py

@@ -85,10 +85,10 @@ def claim_bonds_on_realitio_question(
     responses = sorted(responses, key=lambda x: x.timestamp)
 
     if not responses:
-        raise ValueError(f"No answers found for {question.questionId.hex()=}")
+        raise ValueError(f"No answers found for {question.questionId.to_0x_hex()=}")
 
     if responses[-1].question.historyHash == ZERO_BYTES:
-        raise ValueError(f"Already claimed {question.questionId.hex()=}.")
+        raise ValueError(f"Already claimed {question.questionId.to_0x_hex()=}.")
 
     history_hashes: list[HexBytes] = []
     addresses: list[ChecksumAddress] = []

prediction_market_agent_tooling/markets/omen/omen_subgraph_handler.py

@@ -285,7 +285,7 @@ class OmenSubgraphHandler(BaseSubgraphHandler):
             where_stms["liquidityParameter_gt"] = liquidity_bigger_than
 
         if condition_id_in is not None:
-            where_stms["condition_"]["id_in"] = [x.hex() for x in condition_id_in]
+            where_stms["condition_"]["id_in"] = [x.to_0x_hex() for x in condition_id_in]
 
         if id_in is not None:
             where_stms["id_in"] = [i.lower() for i in id_in]
@@ -513,7 +513,7 @@ class OmenSubgraphHandler(BaseSubgraphHandler):
         where_stms: dict[str, t.Any] = {}
 
         if condition_id is not None:
-            where_stms["conditionIds_contains"] = [condition_id.hex()]
+            where_stms["conditionIds_contains"] = [condition_id.to_0x_hex()]
 
         positions = self.conditional_tokens_subgraph.Query.positions(
             first=sys.maxsize, where=unwrap_generic_value(where_stms)
@@ -541,10 +541,12 @@ class OmenSubgraphHandler(BaseSubgraphHandler):
             where_stms["totalBalance_gt"] = total_balance_bigger_than
 
         if user_position_id_in is not None:
-            where_stms["id_in"] = [x.hex() for x in user_position_id_in]
+            where_stms["id_in"] = [x.to_0x_hex() for x in user_position_id_in]
 
         if position_id_in is not None:
-            where_stms["position_"]["positionId_in"] = [x.hex() for x in position_id_in]
+            where_stms["position_"]["positionId_in"] = [
+                x.to_0x_hex() for x in position_id_in
+            ]
 
         positions = self.conditional_tokens_subgraph.Query.userPositions(
             first=sys.maxsize, where=unwrap_generic_value(where_stms)
@@ -710,13 +712,13 @@ class OmenSubgraphHandler(BaseSubgraphHandler):
             where_stms["user"] = user.lower()
 
         if question_id is not None:
-            where_stms["questionId"] = question_id.hex()
+            where_stms["questionId"] = question_id.to_0x_hex()
 
         if claimed is not None:
             if claimed:
-                where_stms["historyHash"] = ZERO_BYTES.hex()
+                where_stms["historyHash"] = ZERO_BYTES.to_0x_hex()
             else:
-                where_stms["historyHash_not"] = ZERO_BYTES.hex()
+                where_stms["historyHash_not"] = ZERO_BYTES.to_0x_hex()
 
         if current_answer_before is not None:
             where_stms["currentAnswerTimestamp_lt"] = to_int_timestamp(
@@ -750,7 +752,7 @@ class OmenSubgraphHandler(BaseSubgraphHandler):
 
         if question_id_in is not None:
             # Be aware: On Omen subgraph, question's `id` represents `questionId` on reality subgraph. And `id` on reality subraph is just a weird concat of multiple things from the question.
-            where_stms["questionId_in"] = [x.hex() for x in question_id_in]
+            where_stms["questionId_in"] = [x.to_0x_hex() for x in question_id_in]
 
         if excluded_titles:
             # Be aware: This is called `title_not_in` on Omen subgraph.
@@ -777,7 +779,7 @@ class OmenSubgraphHandler(BaseSubgraphHandler):
         where_stms: dict[str, t.Any] = {}
 
         if question_id is not None:
-            where_stms["id"] = question_id.hex()
+            where_stms["id"] = question_id.to_0x_hex()
 
         if current_answer_before is not None:
             where_stms["currentAnswerTimestamp_lt"] = to_int_timestamp(
@@ -811,7 +813,7 @@ class OmenSubgraphHandler(BaseSubgraphHandler):
 
         if question_id_in is not None:
             # Be aware: On Omen subgraph, question's `id` represents `questionId` on reality subgraph. And `id` on reality subraph is just a weird concat of multiple things from the question.
-            where_stms["id_in"] = [x.hex() for x in question_id_in]
+            where_stms["id_in"] = [x.to_0x_hex() for x in question_id_in]
 
         if excluded_titles:
             # Be aware: This is called `qTitle_not_in` on Omen subgraph.
@@ -864,7 +866,7 @@ class OmenSubgraphHandler(BaseSubgraphHandler):
         answer = self.realityeth_subgraph.Answer
         # subgrounds complains if bytes is passed, hence we convert it to HexStr
         where_stms = [
-            answer.question.questionId == question_id.hex(),
+            answer.question.questionId == question_id.to_0x_hex(),
         ]
 
         answers = self.realityeth_subgraph.Query.answers(

prediction_market_agent_tooling/markets/polymarket/api.py

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

prediction_market_agent_tooling/markets/polymarket/clob_manager.py

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

prediction_market_agent_tooling/markets/polymarket/constants.py

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

prediction_market_agent_tooling/markets/polymarket/data_models.py

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