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

prediction_market_agent_tooling/chains.py

@@ -2,3 +2,4 @@ from prediction_market_agent_tooling.gtypes import ChainID
 
 ETHEREUM_ID = ChainID(1)
 GNOSIS_CHAIN_ID = ChainID(100)
+POLYGON_CHAIN_ID = ChainID(137)

prediction_market_agent_tooling/config.py

@@ -2,6 +2,7 @@ import json
 import typing as t
 from copy import deepcopy
 
+import cachetools
 from eth_account.signers.local import LocalAccount
 from eth_typing import URI
 from pydantic import Field, model_validator
@@ -12,8 +13,13 @@ from safe_eth.eth import EthereumClient
 from safe_eth.safe.safe import SafeV141
 from web3 import Account, Web3
 from web3._utils.http import construct_user_agent
+from web3.middleware import ExtraDataToPOAMiddleware
 
-from prediction_market_agent_tooling.chains import ETHEREUM_ID, GNOSIS_CHAIN_ID
+from prediction_market_agent_tooling.chains import (
+    ETHEREUM_ID,
+    GNOSIS_CHAIN_ID,
+    POLYGON_CHAIN_ID,
+)
 from prediction_market_agent_tooling.deploy.gcp.utils import gcp_get_secret_value
 from prediction_market_agent_tooling.gtypes import (
     ChainID,
@@ -293,6 +299,8 @@ class RPCConfig(BaseSettings):
     GNOSIS_RPC_URL: URI = Field(default=URI("https://rpc.gnosis.gateway.fm"))
     GNOSIS_RPC_BEARER: SecretStr | None = None
     CHAIN_ID: ChainID = Field(default=GNOSIS_CHAIN_ID)
+    POLYGON_RPC_URL: URI = Field(default=URI("https://polygon-rpc.com"))
+    POLYGON_RPC_BEARER: SecretStr | None = None
 
     @property
     def ethereum_rpc_url(self) -> URI:
@@ -306,26 +314,40 @@ class RPCConfig(BaseSettings):
             self.GNOSIS_RPC_URL, "GNOSIS_RPC_URL missing in the environment."
         )
 
+    @property
+    def polygon_rpc_url(self) -> URI:
+        return check_not_none(
+            self.POLYGON_RPC_URL, "POLYGON_RPC_URL missing in the environment."
+        )
+
     @property
     def chain_id(self) -> ChainID:
         return check_not_none(self.CHAIN_ID, "CHAIN_ID missing in the environment.")
 
+    @property
+    def gnosis_chain_id(self) -> ChainID:
+        return GNOSIS_CHAIN_ID
+
     def chain_id_to_rpc_url(self, chain_id: ChainID) -> URI:
         return {
             ETHEREUM_ID: self.ethereum_rpc_url,
             GNOSIS_CHAIN_ID: self.gnosis_rpc_url,
+            POLYGON_CHAIN_ID: self.polygon_rpc_url,
         }[chain_id]
 
     def chain_id_to_rpc_bearer(self, chain_id: ChainID) -> SecretStr | None:
         return {
             ETHEREUM_ID: self.ETHEREUM_RPC_BEARER,
             GNOSIS_CHAIN_ID: self.GNOSIS_RPC_BEARER,
+            POLYGON_CHAIN_ID: self.POLYGON_RPC_BEARER,
         }[chain_id]
 
     def get_web3(self) -> Web3:
         headers = {
             "Content-Type": "application/json",
-            "User-Agent": construct_user_agent(str(type(self))),
+            "User-Agent": construct_user_agent(
+                str(type(self)), self.__class__.__name__
+            ),
         }
         if bearer := self.chain_id_to_rpc_bearer(self.chain_id):
             headers["Authorization"] = f"Bearer {bearer.get_secret_value()}"
@@ -339,6 +361,19 @@ class RPCConfig(BaseSettings):
             )
         )
 
+    @cachetools.cached(
+        cachetools.TTLCache(maxsize=100, ttl=5 * 60),
+        key=lambda self: f"{self.model_dump_json()}",
+    )
+    def get_polygon_web3(self) -> Web3:
+        web3 = self.get_web3()
+        if self.chain_id != POLYGON_CHAIN_ID:
+            raise ValueError(f"Chain ID {self.chain_id} is not Polygon Mainnet")
+
+        # We need to inject middleware into the Polygon web3 instance (https://web3py.readthedocs.io/en/stable/middleware.html#proof-of-authority)
+        web3.middleware_onion.inject(ExtraDataToPOAMiddleware, layer=0)
+        return web3
+
 
 class CloudCredentials(BaseSettings):
     model_config = SettingsConfigDict(

prediction_market_agent_tooling/deploy/agent.py

@@ -25,7 +25,6 @@ from prediction_market_agent_tooling.markets.agent_market import (
     ConditionalFilterType,
     FilterBy,
     ProcessedMarket,
-    ProcessedTradedMarket,
     QuestionType,
     SortBy,
 )
@@ -38,9 +37,6 @@ from prediction_market_agent_tooling.markets.data_models import (
     Trade,
 )
 from prediction_market_agent_tooling.markets.markets import MarketType
-from prediction_market_agent_tooling.markets.omen.omen import (
-    send_keeping_token_to_eoa_xdai,
-)
 from prediction_market_agent_tooling.tools.custom_exceptions import (
     CantPayForGasError,
     OutOfFundsError,
@@ -414,15 +410,13 @@ class DeployablePredictionAgent(DeployableAgent):
         """
         Executed before processing of each market.
         """
-        api_keys = APIKeys()
 
         if market_type.is_blockchain_market:
-            # Exchange wxdai back to xdai if the balance is getting low, so we can keep paying for fees.
+            # Ensure we have enough native token balance for transaction fees
             if self.min_balance_to_keep_in_native_currency is not None:
-                send_keeping_token_to_eoa_xdai(
-                    api_keys,
+                market.ensure_min_native_balance(
                     min_required_balance=self.min_balance_to_keep_in_native_currency,
-                    multiplier=3,
+                    multiplier=3.0,
                 )
 
     def build_answer(
@@ -515,7 +509,7 @@ class DeployablePredictionAgent(DeployableAgent):
             self.verify_answer_outcomes(market=market, answer=answer)
 
         processed_market = (
-            ProcessedMarket(answer=answer) if answer is not None else None
+            ProcessedMarket(answer=answer, trades=[]) if answer is not None else None
         )
 
         self.update_langfuse_trace_by_processed_market(market_type, processed_market)
@@ -742,7 +736,7 @@ class DeployableTraderAgent(DeployablePredictionAgent):
         market_type: MarketType,
         market: AgentMarket,
         verify_market: bool = True,
-    ) -> ProcessedTradedMarket | None:
+    ) -> ProcessedMarket | None:
         processed_market = super().process_market(market_type, market, verify_market)
         if processed_market is None:
             return None
@@ -762,7 +756,7 @@ class DeployableTraderAgent(DeployablePredictionAgent):
         )
         placed_trades = self.execute_trades(market, trades)
 
-        traded_market = ProcessedTradedMarket(
+        traded_market = ProcessedMarket(
             answer=processed_market.answer, trades=placed_trades
         )
         logger.info(f"Traded market {market.question=} from {market.url=}.")
@@ -780,10 +774,10 @@ class DeployableTraderAgent(DeployablePredictionAgent):
             market,
             processed_market,
         )
-        if isinstance(processed_market, ProcessedTradedMarket):
-            if self.store_trades:
-                market.store_trades(processed_market, api_keys, self.agent_name)
-            else:
-                logger.info(
-                    f"Trades {processed_market.trades} not stored because {self.store_trades=}."
-                )
+
+        if self.store_trades and processed_market is not None:
+            market.store_trades(processed_market, api_keys, self.agent_name)
+        else:
+            logger.info(
+                f"Trades {processed_market=} not stored because {self.store_trades=}."
+            )

prediction_market_agent_tooling/deploy/betting_strategy.py

@@ -460,7 +460,9 @@ class BinaryKellyBettingStrategy(BettingStrategy):
         amounts = {
             bet_outcome: BettingStrategy.cap_to_profitable_bet_amount(
                 market, market.get_token_in_usd(kelly_bet_size), bet_outcome
-            ),
+            )
+            if kelly_bet_size > 0
+            else USD(0),
         }
         target_position = Position(market_id=market.id, amounts_current=amounts)
         trades = self._build_rebalance_trades_from_positions(
@@ -515,9 +517,15 @@ class BinaryKellyBettingStrategy(BettingStrategy):
             )
             return kelly_bet_size
 
-        pool_balances = [i.as_outcome_wei for i in market.outcome_token_pool.values()]
+        filtered_pool = {
+            outcome: pool_value
+            for outcome, pool_value in market.outcome_token_pool.items()
+            if INVALID_OUTCOME_LOWERCASE_IDENTIFIER not in outcome.lower()
+        }
+
+        pool_balances = [i.as_outcome_wei for i in filtered_pool.values()]
         # stay float for compatibility with `minimize_scalar`
-        total_pool_balance = sum([i.value for i in market.outcome_token_pool.values()])
+        total_pool_balance = sum([i.value for i in filtered_pool.values()])
 
         # The bounds below have been found to work heuristically.
         optimized_bet_amount = minimize_scalar(

prediction_market_agent_tooling/jobs/jobs_models.py

@@ -9,7 +9,7 @@ from prediction_market_agent_tooling.deploy.betting_strategy import (
 from prediction_market_agent_tooling.gtypes import USD, Probability
 from prediction_market_agent_tooling.markets.agent_market import (
     AgentMarket,
-    ProcessedTradedMarket,
+    ProcessedMarket,
 )
 from prediction_market_agent_tooling.markets.omen.data_models import (
     OMEN_FALSE_OUTCOME,
@@ -64,7 +64,7 @@ class JobAgentMarket(AgentMarket, ABC):
     @abstractmethod
     def submit_job_result(
         self, agent_name: str, max_bond: USD, result: str
-    ) -> ProcessedTradedMarket:
+    ) -> ProcessedMarket:
         """Submit the completed result for this job."""
 
     def to_simple_job(self, max_bond: USD) -> SimpleJob:

prediction_market_agent_tooling/jobs/omen/omen_jobs.py

@@ -7,7 +7,7 @@ from prediction_market_agent_tooling.deploy.betting_strategy import (
 )
 from prediction_market_agent_tooling.gtypes import USD
 from prediction_market_agent_tooling.jobs.jobs_models import JobAgentMarket
-from prediction_market_agent_tooling.markets.agent_market import ProcessedTradedMarket
+from prediction_market_agent_tooling.markets.agent_market import ProcessedMarket
 from prediction_market_agent_tooling.markets.data_models import PlacedTrade, Trade
 from prediction_market_agent_tooling.markets.omen.omen import (
     OmenAgentMarket,
@@ -72,7 +72,7 @@ class OmenJobAgentMarket(OmenAgentMarket, JobAgentMarket):
 
     def submit_job_result(
         self, agent_name: str, max_bond: USD, result: str
-    ) -> ProcessedTradedMarket:
+    ) -> ProcessedMarket:
         if not APIKeys().enable_ipfs_upload:
             raise RuntimeError(
                 f"ENABLE_IPFS_UPLOAD must be set to True to upload job results."
@@ -81,7 +81,7 @@ class OmenJobAgentMarket(OmenAgentMarket, JobAgentMarket):
         trade = self.get_job_trade(max_bond, result)
         buy_id = self.buy_tokens(outcome=trade.outcome, amount=trade.amount)
 
-        processed_traded_market = ProcessedTradedMarket(
+        processed_traded_market = ProcessedMarket(
             answer=self.get_job_answer(result),
             trades=[PlacedTrade.from_trade(trade, id=buy_id)],
         )

prediction_market_agent_tooling/markets/agent_market.py

@@ -23,6 +23,7 @@ from prediction_market_agent_tooling.gtypes import (
     OutcomeWei,
     Probability,
     Wei,
+    xDai,
 )
 from prediction_market_agent_tooling.markets.data_models import (
     USD,
@@ -44,9 +45,6 @@ from prediction_market_agent_tooling.tools.utils import (
 
 class ProcessedMarket(BaseModel):
     answer: CategoricalProbabilisticAnswer
-
-
-class ProcessedTradedMarket(ProcessedMarket):
     trades: list[PlacedTrade]
 
 
@@ -450,7 +448,7 @@ class AgentMarket(BaseModel):
 
     def store_trades(
         self,
-        traded_market: ProcessedTradedMarket | None,
+        traded_market: ProcessedMarket | None,
         keys: APIKeys,
         agent_name: str,
         web3: Web3 | None = None,
@@ -509,11 +507,20 @@ class AgentMarket(BaseModel):
             )
 
     def get_outcome_index(self, outcome: OutcomeStr) -> int:
-        outcomes_lowercase = [o.lower() for o in self.outcomes]
+        """Get the index of the given outcome in the market's outcomes."""
         try:
-            return outcomes_lowercase.index(outcome.lower())
-        except ValueError:
-            raise ValueError(f"Outcome `{outcome}` not found in `{self.outcomes}`.")
+            return [o.lower() for o in self.outcomes].index(outcome.lower())
+        except ValueError as e:
+            raise ValueError(
+                f"Outcome '{outcome}' not found in market outcomes: {self.outcomes}"
+            ) from e
+
+    def ensure_min_native_balance(
+        self,
+        min_required_balance: xDai,
+        multiplier: float = 3.0,
+    ) -> None:
+        raise NotImplementedError("Subclass must implement this method")
 
     def get_token_balance(self, user_id: str, outcome: OutcomeStr) -> OutcomeToken:
         raise NotImplementedError("Subclasses must implement this method")
@@ -562,7 +569,7 @@ class AgentMarket(BaseModel):
 
     @staticmethod
     def get_user_id(api_keys: APIKeys) -> str:
-        raise NotImplementedError("Subclasses must implement this method")
+        return api_keys.bet_from_address
 
     def get_most_recent_trade_datetime(self, user_id: str) -> DatetimeUTC | None:
         raise NotImplementedError("Subclasses must implement this method")

prediction_market_agent_tooling/markets/blockchain_utils.py

@@ -11,7 +11,7 @@ from prediction_market_agent_tooling.gtypes import (
     OutcomeStr,
 )
 from prediction_market_agent_tooling.loggers import logger
-from prediction_market_agent_tooling.markets.agent_market import ProcessedTradedMarket
+from prediction_market_agent_tooling.markets.agent_market import ProcessedMarket
 from prediction_market_agent_tooling.markets.omen.data_models import (
     ContractPrediction,
     IPFSAgentResult,
@@ -28,7 +28,7 @@ def store_trades(
     contract: _AgentResultMappingContract,
     market_id: ChecksumAddress,
     outcomes: Sequence[OutcomeStr],
-    traded_market: ProcessedTradedMarket | None,
+    traded_market: ProcessedMarket | None,
     keys: APIKeys,
     agent_name: str,
     web3: Web3 | None = None,
@@ -83,5 +83,5 @@ def store_trades(
         web3=web3,
     )
     logger.info(
-        f"Added prediction to market {market_id}. - receipt {tx_receipt['transactionHash'].hex()}."
+        f"Added prediction to market {market_id}. - receipt {tx_receipt['transactionHash'].to_0x_hex()}."
     )

prediction_market_agent_tooling/markets/omen/data_models.py

@@ -28,6 +28,7 @@ from prediction_market_agent_tooling.markets.omen.omen_constants import (
     OMEN_TRUE_OUTCOME,
 )
 from prediction_market_agent_tooling.tools.contract import (
+    ConditionPreparationEvent,
     ContractERC20OnGnosisChain,
     init_collateral_token_contract,
     to_gnosis_chain_contract,
@@ -47,7 +48,7 @@ OMEN_BINARY_MARKET_OUTCOMES: t.Sequence[OutcomeStr] = [
 ]
 INVALID_ANSWER = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
 INVALID_ANSWER_HEX_BYTES = HexBytes(INVALID_ANSWER)
-INVALID_ANSWER_STR = HexStr(INVALID_ANSWER_HEX_BYTES.hex())
+INVALID_ANSWER_STR = HexStr(INVALID_ANSWER_HEX_BYTES.to_0x_hex())
 OMEN_BASE_URL = "https://aiomen.eth.limo"
 PRESAGIO_BASE_URL = "https://presagio.pages.dev"
 TEST_CATEGORY = "test"  # This category is hidden on Presagio for testing purposes.
@@ -594,7 +595,7 @@ class OmenBet(BaseModel):
             )
 
         return ResolvedBet(
-            id=self.transactionHash.hex(),
+            id=self.transactionHash.to_0x_hex(),
             # Use the transaction hash instead of the bet id - both are valid, but we return the transaction hash from the trade functions, so be consistent here.
             amount=self.collateral_amount_token,
             outcome=self.fpmm.outcomes[self.outcomeIndex],
@@ -795,13 +796,6 @@ class OmenFixedProductMarketMakerCreationEvent(BaseModel):
         return Web3.to_checksum_address(self.collateralToken)
 
 
-class ConditionPreparationEvent(BaseModel):
-    conditionId: HexBytes
-    oracle: HexAddress
-    questionId: HexBytes
-    outcomeSlotCount: int
-
-
 class FPMMFundingAddedEvent(BaseModel):
     funder: HexAddress
     amountsAdded: list[Wei]
@@ -895,12 +889,3 @@ class IPFSAgentResult(BaseModel):
     model_config = ConfigDict(
         extra="forbid",
     )
-
-
-class PayoutRedemptionEvent(BaseModel):
-    redeemer: HexAddress
-    collateralToken: HexAddress
-    parentCollectionId: HexBytes
-    conditionId: HexBytes
-    indexSets: list[int]
-    payout: Wei

prediction_market_agent_tooling/markets/omen/omen.py

@@ -6,6 +6,7 @@ import tenacity
 from pydantic import BaseModel
 from tqdm import tqdm
 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 (
@@ -28,7 +29,6 @@ from prediction_market_agent_tooling.markets.agent_market import (
     FilterBy,
     MarketFees,
     ProcessedMarket,
-    ProcessedTradedMarket,
     QuestionType,
     SortBy,
 )
@@ -43,7 +43,6 @@ from prediction_market_agent_tooling.markets.omen.data_models import (
     OMEN_TRUE_OUTCOME,
     PRESAGIO_BASE_URL,
     Condition,
-    ConditionPreparationEvent,
     CreatedMarket,
     OmenBet,
     OmenMarket,
@@ -60,13 +59,13 @@ from prediction_market_agent_tooling.markets.omen.omen_contracts import (
     OmenOracleContract,
     OmenRealitioContract,
     WrappedxDaiContract,
-    build_parent_collection_id,
 )
 from prediction_market_agent_tooling.markets.omen.omen_subgraph_handler import (
     OmenSubgraphHandler,
 )
 from prediction_market_agent_tooling.tools.balances import get_balances
 from prediction_market_agent_tooling.tools.contract import (
+    ConditionPreparationEvent,
     init_collateral_token_contract,
     to_gnosis_chain_contract,
 )
@@ -411,6 +410,26 @@ class OmenAgentMarket(AgentMarket):
     def redeem_winnings(api_keys: APIKeys) -> None:
         redeem_from_all_user_positions(api_keys)
 
+    def ensure_min_native_balance(
+        self,
+        min_required_balance: xDai,
+        multiplier: float = 3.0,
+    ) -> None:
+        """
+        Ensure the EOA has at least the minimum required native token balance.
+        If not, transfer wrapped native tokens from the betting address and unwrap them.
+
+        Args:
+            min_required_balance: Minimum required native token balance to maintain
+            multiplier: Multiplier to apply to the required balance to keep as a buffer
+        """
+
+        send_keeping_token_to_eoa_xdai(
+            api_keys=APIKeys(),
+            min_required_balance=min_required_balance,
+            multiplier=multiplier,
+        )
+
     @staticmethod
     def get_trade_balance(api_keys: APIKeys, web3: Web3 | None = None) -> USD:
         native_usd = get_xdai_in_usd(
@@ -438,7 +457,7 @@ class OmenAgentMarket(AgentMarket):
 
     def store_trades(
         self,
-        traded_market: ProcessedTradedMarket | None,
+        traded_market: ProcessedMarket | None,
         keys: APIKeys,
         agent_name: str,
         web3: Web3 | None = None,
@@ -653,10 +672,6 @@ class OmenAgentMarket(AgentMarket):
     def get_user_balance(user_id: str) -> float:
         return float(get_balances(Web3.to_checksum_address(user_id)).total)
 
-    @staticmethod
-    def get_user_id(api_keys: APIKeys) -> str:
-        return api_keys.bet_from_address
-
     def get_most_recent_trade_datetime(self, user_id: str) -> DatetimeUTC | None:
         sgh = OmenSubgraphHandler()
         trades = sgh.get_trades(
@@ -734,7 +749,7 @@ def omen_buy_outcome_tx(
         web3=web3,
     )
 
-    return tx_receipt["transactionHash"].hex()
+    return tx_receipt["transactionHash"].to_0x_hex()
 
 
 def binary_omen_buy_outcome_tx(
@@ -828,7 +843,7 @@ def omen_sell_outcome_tx(
             web3=web3,
         )
 
-    return tx_receipt["transactionHash"].hex()
+    return tx_receipt["transactionHash"].to_0x_hex()
 
 
 def binary_omen_sell_outcome_tx(
@@ -1076,7 +1091,7 @@ def get_conditional_tokens_balance_for_market(
     """
     balance_per_index_set: dict[int, OutcomeWei] = {}
     conditional_token_contract = OmenConditionalTokenContract()
-    parent_collection_id = build_parent_collection_id()
+    parent_collection_id = HASH_ZERO
 
     for index_set in market.condition.index_sets:
         collection_id = conditional_token_contract.getCollectionId(