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

prediction_market_agent_tooling/markets/polymarket/polymarket.py

@@ -1,22 +1,65 @@
 import typing as t
 
-from prediction_market_agent_tooling.gtypes import USD, CollateralToken, OutcomeStr
+import cachetools
+from web3 import Web3
+
+from prediction_market_agent_tooling.config import APIKeys, RPCConfig
+from prediction_market_agent_tooling.gtypes import (
+    USD,
+    ChecksumAddress,
+    CollateralToken,
+    HexBytes,
+    OutcomeStr,
+    OutcomeToken,
+    Probability,
+    Wei,
+    xDai,
+)
+from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.markets.agent_market import (
     AgentMarket,
+    ConditionalFilterType,
     FilterBy,
     MarketFees,
+    ProcessedMarket,
+    QuestionType,
     SortBy,
 )
+from prediction_market_agent_tooling.markets.data_models import (
+    ExistingPosition,
+    Resolution,
+)
 from prediction_market_agent_tooling.markets.polymarket.api import (
-    get_polymarket_binary_markets,
+    PolymarketOrderByEnum,
+    get_polymarkets_with_pagination,
+    get_user_positions,
 )
-from prediction_market_agent_tooling.markets.polymarket.data_models import (
-    PolymarketMarketWithPrices,
+from prediction_market_agent_tooling.markets.polymarket.clob_manager import (
+    ClobManager,
+    PolymarketPriceSideEnum,
+)
+from prediction_market_agent_tooling.markets.polymarket.constants import (
+    POLYMARKET_TINY_BET_AMOUNT,
 )
-from prediction_market_agent_tooling.markets.polymarket.data_models_web import (
+from prediction_market_agent_tooling.markets.polymarket.data_models import (
     POLYMARKET_BASE_URL,
+    PolymarketGammaResponseDataItem,
+)
+from prediction_market_agent_tooling.markets.polymarket.polymarket_contracts import (
+    PolymarketConditionalTokenContract,
+    USDCeContract,
+)
+from prediction_market_agent_tooling.markets.polymarket.polymarket_subgraph_handler import (
+    ConditionSubgraphModel,
+    PolymarketSubgraphHandler,
+)
+from prediction_market_agent_tooling.tools.datetime_utc import DatetimeUTC
+from prediction_market_agent_tooling.tools.tokens.usd import get_token_in_usd
+from prediction_market_agent_tooling.tools.utils import check_not_none
+
+SHARED_CACHE: cachetools.TTLCache[t.Hashable, t.Any] = cachetools.TTLCache(
+    maxsize=256, ttl=10 * 60
 )
-from prediction_market_agent_tooling.tools.utils import DatetimeUTC
 
 
 class PolymarketAgentMarket(AgentMarket):
@@ -31,25 +74,111 @@ class PolymarketAgentMarket(AgentMarket):
     # But then in the new subgraph API, they have `fee: BigInt! (Percentage fee of trades taken by market maker. A 2% fee is represented as 2*10^16)`.
     # TODO: Check out the fees while integrating the subgraph API or if we implement placing of bets on Polymarket.
     fees: MarketFees = MarketFees.get_zero_fees()
+    condition_id: HexBytes
+    liquidity_usd: USD
+    token_ids: list[int]
+    closed_flag_from_polymarket: bool
+    active_flag_from_polymarket: bool
 
     @staticmethod
-    def from_data_model(model: PolymarketMarketWithPrices) -> "PolymarketAgentMarket":
+    def collateral_token_address() -> ChecksumAddress:
+        return USDCeContract().address
+
+    @staticmethod
+    def build_resolution_from_condition(
+        condition_id: HexBytes,
+        condition_model_dict: dict[HexBytes, ConditionSubgraphModel],
+        outcomes: list[OutcomeStr],
+    ) -> Resolution | None:
+        condition_model = condition_model_dict.get(condition_id)
+        if (
+            not condition_model
+            or condition_model.resolutionTimestamp is None
+            or not condition_model.payoutNumerators
+            or not condition_model.payoutDenominator
+        ):
+            return None
+
+        # Currently we only support binary markets, hence we throw an error if we get something else.
+        payout_numerator_indices_gt_0 = [
+            idx
+            for idx, value in enumerate(condition_model.payoutNumerators)
+            if value > 0
+        ]
+        # For a binary market, there should be exactly one payout numerator greater than 0.
+        if len(payout_numerator_indices_gt_0) != 1:
+            # These cases involve multi-categorical resolution (to be implemented https://github.com/gnosis/prediction-market-agent-tooling/issues/770)
+            logger.warning(
+                f"Only binary markets are supported. Got payout numerators: {condition_model.payoutNumerators} for condition_id {condition_id.to_0x_hex()}"
+            )
+            return Resolution(outcome=None, invalid=False)
+
+        # we return the only payout numerator greater than 0 as resolution
+        resolved_outcome = outcomes[payout_numerator_indices_gt_0[0]]
+        return Resolution.from_answer(resolved_outcome)
+
+    def get_token_id_for_outcome(self, outcome: OutcomeStr) -> int:
+        outcome_idx = self.outcomes.index(outcome)
+        return self.token_ids[outcome_idx]
+
+    @staticmethod
+    def from_data_model(
+        model: PolymarketGammaResponseDataItem,
+        condition_model_dict: dict[HexBytes, ConditionSubgraphModel],
+    ) -> t.Optional["PolymarketAgentMarket"]:
+        # If len(model.markets) > 0, this denotes a categorical market.
+        markets = check_not_none(model.markets)
+        outcomes = markets[0].outcomes_list
+        outcome_prices = markets[0].outcome_prices
+        if not outcome_prices:
+            logger.info(f"Market has no outcome prices. Skipping. {model=}")
+            return None
+
+        probabilities = {o: Probability(op) for o, op in zip(outcomes, outcome_prices)}
+
+        condition_id = markets[0].conditionId
+        resolution = PolymarketAgentMarket.build_resolution_from_condition(
+            condition_id=condition_id,
+            condition_model_dict=condition_model_dict,
+            outcomes=outcomes,
+        )
+
         return PolymarketAgentMarket(
             id=model.id,
-            question=model.question,
+            condition_id=condition_id,
+            question=model.title,
             description=model.description,
-            outcomes=[x.outcome for x in model.tokens],
-            resolution=model.resolution,
-            created_time=None,
-            close_time=model.end_date_iso,
+            outcomes=outcomes,
+            resolution=resolution,
+            created_time=model.startDate,
+            close_time=model.endDate,
+            closed_flag_from_polymarket=model.closed,
+            active_flag_from_polymarket=model.active,
             url=model.url,
-            volume=None,
+            volume=CollateralToken(model.volume) if model.volume else None,
             outcome_token_pool=None,
-            probabilities={},  # ToDo - Implement when fixing Polymarket
+            probabilities=probabilities,
+            liquidity_usd=USD(model.liquidity)
+            if model.liquidity is not None
+            else USD(0),
+            token_ids=markets[0].token_ids,
         )
 
     def get_tiny_bet_amount(self) -> CollateralToken:
-        raise NotImplementedError("TODO: Implement to allow betting on Polymarket.")
+        return CollateralToken(POLYMARKET_TINY_BET_AMOUNT.value)
+
+    def get_token_in_usd(self, x: CollateralToken) -> USD:
+        return get_token_in_usd(x, self.collateral_token_address())
+
+    @staticmethod
+    def get_trade_balance(api_keys: APIKeys, web3: Web3 | None = None) -> USD:
+        usdc_balance_wei = USDCeContract().balanceOf(
+            for_address=api_keys.public_key, web3=web3
+        )
+        return USD(usdc_balance_wei.value * 1e-6)
+
+    def get_liquidity(self, web3: Web3 | None = None) -> CollateralToken:
+        return CollateralToken(self.liquidity_usd.value)
 
     def place_bet(self, outcome: OutcomeStr, amount: USD) -> str:
         raise NotImplementedError("TODO: Implement to allow betting on Polymarket.")
@@ -61,15 +190,11 @@ class PolymarketAgentMarket(AgentMarket):
         filter_by: FilterBy = FilterBy.OPEN,
         created_after: t.Optional[DatetimeUTC] = None,
         excluded_questions: set[str] | None = None,
-        fetch_categorical_markets: bool = False,
+        question_type: QuestionType = QuestionType.ALL,
+        conditional_filter_type: ConditionalFilterType = ConditionalFilterType.ONLY_NOT_CONDITIONAL,
     ) -> t.Sequence["PolymarketAgentMarket"]:
-        if sort_by != SortBy.NONE:
-            raise ValueError(f"Unsuported sort_by {sort_by} for Polymarket.")
-
-        if created_after is not None:
-            raise ValueError(f"Unsuported created_after for Polymarket.")
-
         closed: bool | None
+
         if filter_by == FilterBy.OPEN:
             closed = False
         elif filter_by == FilterBy.RESOLVED:
@@ -79,11 +204,230 @@ class PolymarketAgentMarket(AgentMarket):
         else:
             raise ValueError(f"Unknown filter_by: {filter_by}")
 
-        return [
-            PolymarketAgentMarket.from_data_model(m)
-            for m in get_polymarket_binary_markets(
-                limit=limit,
-                closed=closed,
-                excluded_questions=excluded_questions,
+        ascending: bool = False  # default value
+        match sort_by:
+            case SortBy.NEWEST:
+                order_by = PolymarketOrderByEnum.START_DATE
+                ascending = False
+            case SortBy.CLOSING_SOONEST:
+                ascending = True
+                order_by = PolymarketOrderByEnum.END_DATE
+            case SortBy.HIGHEST_LIQUIDITY:
+                order_by = PolymarketOrderByEnum.LIQUIDITY
+            case SortBy.NONE:
+                order_by = PolymarketOrderByEnum.VOLUME_24HR
+            case _:
+                raise ValueError(f"Unknown sort_by: {sort_by}")
+
+        # closed markets also have property active=True, hence ignoring active.
+        markets = get_polymarkets_with_pagination(
+            limit=limit,
+            closed=closed,
+            order_by=order_by,
+            ascending=ascending,
+            created_after=created_after,
+            excluded_questions=excluded_questions,
+            only_binary=question_type is not QuestionType.CATEGORICAL,
+        )
+
+        condition_models = PolymarketSubgraphHandler().get_conditions(
+            condition_ids=list(
+                set(
+                    [
+                        market.markets[0].conditionId
+                        for market in markets
+                        if market.markets is not None
+                    ]
+                )
             )
-        ]
+        )
+        condition_models_dict = {c.id: c for c in condition_models}
+
+        result_markets: list[PolymarketAgentMarket] = []
+        for m in markets:
+            market = PolymarketAgentMarket.from_data_model(m, condition_models_dict)
+            if market is not None:
+                result_markets.append(market)
+        return result_markets
+
+    def ensure_min_native_balance(
+        self,
+        min_required_balance: xDai,
+        multiplier: float = 3.0,
+        web3: Web3 | None = None,
+    ) -> None:
+        balance_collateral = USDCeContract().balanceOf(
+            for_address=APIKeys().public_key, web3=web3
+        )
+        # USDC has 6 decimals, xDAI has 18. We convert from Wei into atomic units.
+        balance_collateral_atomic = CollateralToken(float(balance_collateral) / 1e6)
+        if balance_collateral_atomic < min_required_balance.as_token:
+            raise EnvironmentError(
+                f"USDC balance {balance_collateral_atomic} < {min_required_balance.as_token=}"
+            )
+
+    @staticmethod
+    def redeem_winnings(api_keys: APIKeys, web3: Web3 | None = None) -> None:
+        web3 = web3 or RPCConfig().get_polygon_web3()
+        user_id = api_keys.bet_from_address
+        conditional_token_contract = PolymarketConditionalTokenContract()
+        positions = PolymarketSubgraphHandler().get_market_positions_from_user(user_id)
+        for pos in positions:
+            if (
+                pos.market.condition.resolutionTimestamp is None
+                or pos.market.condition.payoutNumerators is None
+            ):
+                continue
+
+            condition_id = pos.market.condition.id
+            index_sets = pos.market.condition.index_sets
+
+            redeem_event = conditional_token_contract.redeemPositions(
+                api_keys=api_keys,
+                collateral_token_address=USDCeContract().address,
+                condition_id=condition_id,
+                index_sets=index_sets,
+                web3=web3,
+            )
+
+            logger.info(f"Redeemed {redeem_event=} from condition_id {condition_id=}.")
+
+    @staticmethod
+    def verify_operational_balance(api_keys: APIKeys) -> bool:
+        """Method for checking if agent has enough funds to pay for gas fees."""
+        web3 = RPCConfig().get_polygon_web3()
+        pol_balance: Wei = Wei(web3.eth.get_balance(api_keys.public_key))
+        return pol_balance > Wei(int(0.001 * 1e18))
+
+    def store_prediction(
+        self,
+        processed_market: ProcessedMarket | None,
+        keys: APIKeys,
+        agent_name: str,
+    ) -> None:
+        pass
+
+    def store_trades(
+        self,
+        traded_market: ProcessedMarket | None,
+        keys: APIKeys,
+        agent_name: str,
+        web3: Web3 | None = None,
+    ) -> None:
+        logger.info("Storing trades deactivated for Polymarket.")
+        # Understand how market_id can be represented.
+        # Condition_id could work but length doesn't seem to match.
+
+    @classmethod
+    def get_user_url(cls, keys: APIKeys) -> str:
+        return f"https://polymarket.com/{keys.public_key}"
+
+    def get_position(
+        self, user_id: str, web3: Web3 | None = None
+    ) -> ExistingPosition | None:
+        """
+        Fetches position from the user in a given market.
+        """
+        positions = get_user_positions(
+            user_id=Web3.to_checksum_address(user_id), condition_ids=[self.condition_id]
+        )
+        if not positions:
+            return None
+
+        amounts_ot = {i: OutcomeToken(0) for i in self.outcomes}
+        amounts_potential = {i: USD(0) for i in self.outcomes}
+        amounts_current = {i: USD(0) for i in self.outcomes}
+
+        for p in positions:
+            if p.conditionId != self.condition_id.to_0x_hex():
+                continue
+
+            amounts_potential[OutcomeStr(p.outcome)] = USD(p.size)
+            amounts_ot[OutcomeStr(p.outcome)] = OutcomeToken(p.size)
+            amounts_current[OutcomeStr(p.outcome)] = USD(p.currentValue)
+
+        return ExistingPosition(
+            amounts_potential=amounts_potential,
+            amounts_ot=amounts_ot,
+            market_id=self.id,
+            amounts_current=amounts_current,
+        )
+
+    def can_be_traded(self) -> bool:
+        return (
+            self.active_flag_from_polymarket
+            and not self.closed_flag_from_polymarket
+            and self.liquidity_usd
+            > USD(5)  # we conservatively require some positive liquidity to trade on
+        )
+
+    def get_buy_token_amount(
+        self, bet_amount: USD | CollateralToken, outcome_str: OutcomeStr
+    ) -> OutcomeToken:
+        """Returns number of outcome tokens returned for a given bet expressed in collateral units."""
+
+        if outcome_str not in self.outcomes:
+            raise ValueError(
+                f"Outcome {outcome_str} not found in market outcomes {self.outcomes}"
+            )
+
+        token_id = self.get_token_id_for_outcome(outcome_str)
+
+        price = ClobManager(APIKeys()).get_token_price(
+            token_id=token_id, side=PolymarketPriceSideEnum.BUY
+        )
+        if not price:
+            raise ValueError(
+                f"Could not get price for outcome {outcome_str} with token_id {token_id}"
+            )
+
+        # we work with floats since USD and Collateral are the same on Polymarket
+        buy_token_amount = bet_amount.value / price.value
+        logger.info(f"Buy token amount: {buy_token_amount=}")
+        return OutcomeToken(buy_token_amount)
+
+    def buy_tokens(self, outcome: OutcomeStr, amount: USD) -> str:
+        clob_manager = ClobManager(APIKeys())
+        token_id = self.get_token_id_for_outcome(outcome)
+
+        created_order = clob_manager.place_buy_market_order(
+            token_id=token_id, usdc_amount=amount
+        )
+        if not created_order.success:
+            raise ValueError(f"Error creating order: {created_order}")
+
+        return created_order.transactionsHashes[0].to_0x_hex()
+
+    def sell_tokens(
+        self,
+        outcome: OutcomeStr,
+        amount: USD | OutcomeToken,
+        api_keys: APIKeys | None = None,
+    ) -> str:
+        """
+        Polymarket's API expect shares to be sold. 1 share == 1 outcome token / 1e6.
+        The number of outcome tokens matches the `balanceOf` of the conditionalTokens contract.
+        In comparison, the number of shares match the position.size from the user position.
+        """
+        logger.info(f"Selling {amount=} from {outcome=}")
+        clob_manager = ClobManager(api_keys=api_keys or APIKeys())
+        token_id = self.get_token_id_for_outcome(outcome)
+        token_shares: OutcomeToken
+        if isinstance(amount, OutcomeToken):
+            token_shares = amount
+        elif isinstance(amount, USD):
+            token_price = clob_manager.get_token_price(
+                token_id=token_id, side=PolymarketPriceSideEnum.SELL
+            )
+            # We expect that our order sizes don't move the price too much.
+            token_shares = OutcomeToken(amount.value / token_price.value)
+        else:
+            raise ValueError(f"Unsupported amount type {type(amount)}")
+
+        created_order = clob_manager.place_sell_market_order(
+            token_id=token_id, token_shares=token_shares
+        )
+        if not created_order.success:
+            raise ValueError(f"Error creating order: {created_order}")
+
+        return created_order.transactionsHashes[0].to_0x_hex()

prediction_market_agent_tooling/markets/polymarket/polymarket_contracts.py

@@ -0,0 +1,35 @@
+from web3 import Web3
+
+from prediction_market_agent_tooling.config import APIKeys
+from prediction_market_agent_tooling.gtypes import ChecksumAddress
+from prediction_market_agent_tooling.tools.contract import (
+    ConditionalTokenContract,
+    ContractERC20BaseClass,
+    ContractOnPolygonChain,
+)
+
+
+class USDCeContract(ContractERC20BaseClass, ContractOnPolygonChain):
+    # USDC.e is used by Polymarket.
+    address: ChecksumAddress = Web3.to_checksum_address(
+        "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174"
+    )
+
+
+class PolymarketConditionalTokenContract(
+    ConditionalTokenContract, ContractOnPolygonChain
+):
+    address: ChecksumAddress = Web3.to_checksum_address(
+        "0x4D97DCd97eC945f40cF65F87097ACe5EA0476045"
+    )
+
+    def approve_if_not_approved(
+        self, api_keys: APIKeys, for_address: ChecksumAddress, web3: Web3 | None = None
+    ) -> None:
+        is_approved = self.isApprovedForAll(
+            owner=api_keys.public_key, for_address=for_address, web3=web3
+        )
+        if not is_approved:
+            self.setApprovalForAll(
+                api_keys=api_keys, for_address=for_address, approve=True, web3=web3
+            )

prediction_market_agent_tooling/markets/polymarket/polymarket_subgraph_handler.py

@@ -0,0 +1,91 @@
+from pydantic import BaseModel
+from subgrounds import FieldPath
+
+from prediction_market_agent_tooling.gtypes import ChecksumAddress, HexBytes
+from prediction_market_agent_tooling.markets.base_subgraph_handler import (
+    BaseSubgraphHandler,
+)
+
+
+class ConditionSubgraphModel(BaseModel):
+    id: HexBytes
+    payoutDenominator: int | None = None
+    payoutNumerators: list[int] | None = None
+    outcomeSlotCount: int
+    resolutionTimestamp: int | None = None
+    questionId: HexBytes
+
+    @property
+    def index_sets(self) -> list[int]:
+        return [i + 1 for i in range(self.outcomeSlotCount)]
+
+
+class MarketPositionMarket(BaseModel):
+    condition: ConditionSubgraphModel
+
+
+class MarketPosition(BaseModel):
+    id: HexBytes
+    market: MarketPositionMarket
+
+
+class PolymarketSubgraphHandler(BaseSubgraphHandler):
+    POLYMARKET_CONDITIONS_SUBGRAPH = "https://gateway.thegraph.com/api/{graph_api_key}/subgraphs/id/81Dm16JjuFSrqz813HysXoUPvzTwE7fsfPk2RTf66nyC"
+
+    def __init__(self) -> None:
+        super().__init__()
+
+        # Load the subgraph
+        self.conditions_subgraph = self.sg.load_subgraph(
+            self.POLYMARKET_CONDITIONS_SUBGRAPH.format(
+                graph_api_key=self.keys.graph_api_key.get_secret_value()
+            )
+        )
+
+    def _get_fields_for_condition(self, field: FieldPath) -> list[FieldPath]:
+        return [
+            field.id,
+            field.questionId,
+            field.payoutNumerators,
+            field.payoutDenominator,
+            field.outcomeSlotCount,
+            field.resolutionTimestamp,
+        ]
+
+    def get_conditions(
+        self, condition_ids: list[HexBytes]
+    ) -> list[ConditionSubgraphModel]:
+        where_stms = {"id_in": [i.to_0x_hex() for i in condition_ids]}
+        conditions = self.conditions_subgraph.Query.conditions(
+            first=len(condition_ids),
+            where=where_stms,
+        )
+
+        condition_fields = self._get_fields_for_condition(conditions)
+
+        conditions_models = self.do_query(
+            fields=condition_fields, pydantic_model=ConditionSubgraphModel
+        )
+        return conditions_models
+
+    def get_market_positions_from_user(
+        self,
+        user: ChecksumAddress,
+        first: int = 1000,
+        block_number: int | None = None,
+    ) -> list[MarketPosition]:
+        # Not possible to filter using `market_.condition` on a subgraph level, bad indexers error.
+        positions = self.conditions_subgraph.Query.marketPositions(
+            first=first,
+            where={"user": user.lower()},
+            block={"number": block_number} if block_number else None,
+        )
+
+        condition_fields = self._get_fields_for_condition(
+            positions.market.condition
+        ) + [positions.id]
+
+        positions_models = self.do_query(
+            fields=condition_fields, pydantic_model=MarketPosition
+        )
+        return positions_models

prediction_market_agent_tooling/markets/polymarket/utils.py

@@ -1,28 +1,7 @@
-from prediction_market_agent_tooling.markets.data_models import Resolution
-from prediction_market_agent_tooling.markets.markets import MarketType
-from prediction_market_agent_tooling.markets.polymarket.data_models_web import (
-    PolymarketFullMarket,
-)
+from prediction_market_agent_tooling.markets.market_type import MarketType
 from prediction_market_agent_tooling.tools.google_utils import search_google_gcp
 
 
-def find_resolution_on_polymarket(question: str) -> Resolution | None:
-    full_market = find_full_polymarket(question)
-    # TODO: Only main markets are supported right now, add logic for others if needed.
-    return (
-        full_market.main_market.resolution
-        if full_market and full_market.is_main_market
-        else None
-    )
-
-
-def find_full_polymarket(question: str) -> PolymarketFullMarket | None:
-    polymarket_url = find_url_to_polymarket(question)
-    return (
-        PolymarketFullMarket.fetch_from_url(polymarket_url) if polymarket_url else None
-    )
-
-
 def find_url_to_polymarket(question: str) -> str | None:
     # Manually create potential Polymarket's slug from the question.
     replace_chars = {