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

prediction_market_agent_tooling/markets/omen/data_models.py

@@ -1,4 +1,5 @@
 import typing as t
+from datetime import timedelta
 
 from pydantic import BaseModel, ConfigDict, Field, computed_field, model_validator
 from web3 import Web3
@@ -23,7 +24,12 @@ from prediction_market_agent_tooling.markets.data_models import (
     Resolution,
     ResolvedBet,
 )
+from prediction_market_agent_tooling.markets.omen.omen_constants import (
+    OMEN_FALSE_OUTCOME,
+    OMEN_TRUE_OUTCOME,
+)
 from prediction_market_agent_tooling.tools.contract import (
+    ConditionPreparationEvent,
     ContractERC20OnGnosisChain,
     init_collateral_token_contract,
     to_gnosis_chain_contract,
@@ -37,15 +43,13 @@ from prediction_market_agent_tooling.tools.utils import (
     utcnow,
 )
 
-OMEN_TRUE_OUTCOME = OutcomeStr("Yes")
-OMEN_FALSE_OUTCOME = OutcomeStr("No")
 OMEN_BINARY_MARKET_OUTCOMES: t.Sequence[OutcomeStr] = [
     OMEN_TRUE_OUTCOME,
     OMEN_FALSE_OUTCOME,
 ]
 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.
@@ -83,6 +87,7 @@ class Question(BaseModel):
     templateId: int
     outcomes: t.Sequence[OutcomeStr]
     isPendingArbitration: bool
+    timeout: int  # Finalization time in seconds
     openingTimestamp: int
     answerFinalizedTimestamp: t.Optional[DatetimeUTC] = None
     currentAnswer: t.Optional[str] = None
@@ -96,6 +101,10 @@ class Question(BaseModel):
         # Based on https://github.com/protofire/omen-exchange/blob/2cfdf6bfe37afa8b169731d51fea69d42321d66c/app/src/hooks/graph/useGraphMarketMakerData.tsx#L217.
         return self.data
 
+    @property
+    def timeout_timedelta(self) -> timedelta:
+        return timedelta(seconds=self.timeout)
+
     @property
     def n_outcomes(self) -> int:
         return len(self.outcomes)
@@ -253,6 +262,10 @@ class OmenMarket(BaseModel):
 
         return self
 
+    @property
+    def creator_checksum(self) -> ChecksumAddress:
+        return Web3.to_checksum_address(self.creator)
+
     @property
     def openingTimestamp(self) -> int:
         # This field is also available on this model itself, but for some reason it's typed to be optional,
@@ -468,6 +481,7 @@ class OmenMarket(BaseModel):
                 outcomes=model.question_event.parsed_question.outcomes,
                 isPendingArbitration=False,  # Can not be, it's a fresh market.
                 openingTimestamp=model.question_event.opening_ts,
+                timeout=model.question_event.timeout,
                 answerFinalizedTimestamp=None,  # It's a new one, can not be.
                 currentAnswer=None,  # It's a new one, no answer yet.
             ),
@@ -592,14 +606,19 @@ 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],
             created_time=self.creation_datetime,
             market_question=self.title,
             market_id=self.fpmm.id,
-            market_outcome=self.fpmm.outcomes[self.outcomeIndex],
+            market_outcome=self.fpmm.outcomes[
+                check_not_none(
+                    self.fpmm.answer_index,
+                    "Should not be None if `is_resolved_with_valid_answer`.",
+                )
+            ],
             resolved_time=check_not_none(self.fpmm.finalized_datetime),
             profit=self.get_profit(),
         )
@@ -788,13 +807,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]
@@ -826,18 +838,44 @@ class CreatedMarket(BaseModel):
 
 class ContractPrediction(BaseModel):
     model_config = ConfigDict(populate_by_name=True)
+
+    market: str | None = Field(
+        None,
+        alias="marketAddress",
+        description="Market's address. Will be None on older records.",
+    )
     publisher: str = Field(..., alias="publisherAddress")
     ipfs_hash: HexBytes = Field(..., alias="ipfsHash")
     tx_hashes: list[HexBytes] = Field(..., alias="txHashes")
-    estimated_probability_bps: int = Field(..., alias="estimatedProbabilityBps")
+    outcomes: list[OutcomeStr] = Field(...)
+    estimated_probabilities_bps: list[int] = Field(
+        ..., alias="estimatedProbabilitiesBps"
+    )
 
-    @property
-    def estimated_probability(self) -> Probability:
-        return Probability(self.estimated_probability_bps / BPS_CONSTANT)
+    @model_validator(mode="before")
+    @classmethod
+    def handle_legacy_estimated_probability_bps(
+        cls, values: dict[str, t.Any]
+    ) -> dict[str, t.Any]:
+        # If 'estimatedProbabilityBps' is present and 'outcomes'/'estimatedProbabilitiesBps' are not,
+        # convert to the new format using "Yes" and "No" outcomes.
+        # This allows for backward compatibility with old contract events.
+        if (
+            "estimatedProbabilityBps" in values
+            and "outcomes" not in values
+            and "estimatedProbabilitiesBps" not in values
+        ):
+            prob_bps = values["estimatedProbabilityBps"]
+            values["outcomes"] = [
+                OMEN_TRUE_OUTCOME,
+                OMEN_FALSE_OUTCOME,
+            ]
+            values["estimatedProbabilitiesBps"] = [prob_bps, BPS_CONSTANT - prob_bps]
+        return values
 
-    @property
-    def boolean_outcome(self) -> bool:
-        return self.estimated_probability > 0.5
+    def estimated_probability_of_outcome(self, outcome: OutcomeStr) -> Probability:
+        index = self.outcomes.index(outcome)
+        return Probability(self.estimated_probabilities_bps[index] / BPS_CONSTANT)
 
     @computed_field  # type: ignore[prop-decorator] # Mypy issue: https://github.com/python/mypy/issues/14461
     @property
@@ -847,10 +885,12 @@ class ContractPrediction(BaseModel):
     @staticmethod
     def from_tuple(values: tuple[t.Any, ...]) -> "ContractPrediction":
         return ContractPrediction(
-            publisher=values[0],
-            ipfs_hash=values[1],
-            tx_hashes=values[2],
-            estimated_probability_bps=values[3],
+            market=values[0],
+            publisher=values[1],
+            ipfs_hash=values[2],
+            tx_hashes=values[3],
+            outcomes=values[4],
+            estimated_probabilities_bps=values[5],
         )
 
 
@@ -860,12 +900,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

@@ -3,8 +3,10 @@ from collections import defaultdict
 from datetime import timedelta
 
 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 (
@@ -23,10 +25,11 @@ from prediction_market_agent_tooling.gtypes import (
 from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.markets.agent_market import (
     AgentMarket,
+    ConditionalFilterType,
     FilterBy,
     MarketFees,
     ProcessedMarket,
-    ProcessedTradedMarket,
+    QuestionType,
     SortBy,
 )
 from prediction_market_agent_tooling.markets.blockchain_utils import store_trades
@@ -40,7 +43,6 @@ from prediction_market_agent_tooling.markets.omen.data_models import (
     OMEN_TRUE_OUTCOME,
     PRESAGIO_BASE_URL,
     Condition,
-    ConditionPreparationEvent,
     CreatedMarket,
     OmenBet,
     OmenMarket,
@@ -50,19 +52,20 @@ from prediction_market_agent_tooling.markets.omen.omen_contracts import (
     OMEN_DEFAULT_MARKET_FEE_PERC,
     REALITY_DEFAULT_FINALIZATION_TIMEOUT,
     Arbitrator,
+    OmenAgentResultMappingContract,
     OmenConditionalTokenContract,
     OmenFixedProductMarketMakerContract,
     OmenFixedProductMarketMakerFactoryContract,
     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,
 )
@@ -84,10 +87,10 @@ from prediction_market_agent_tooling.tools.utils import (
     DatetimeUTC,
     calculate_sell_amount_in_collateral,
     check_not_none,
+    utcnow,
 )
 from prediction_market_agent_tooling.tools.web3_utils import get_receipt_block_timestamp
 
-OMEN_DEFAULT_REALITIO_BOND_VALUE = xDai(0.01)
 # Too low value would work with the Omen contract, but causes CoW orders (when buying the specific market's tokens) to fail.
 OMEN_TINY_BET_AMOUNT = USD(0.01)
 
@@ -102,6 +105,7 @@ class OmenAgentMarket(AgentMarket):
 
     collateral_token_contract_address_checksummed: ChecksumAddress
     market_maker_contract_address_checksummed: ChecksumAddress
+    outcome_token_pool: dict[OutcomeStr, OutcomeToken]
     condition: Condition
     finalized_time: DatetimeUTC | None
     created_time: DatetimeUTC
@@ -157,6 +161,14 @@ class OmenAgentMarket(AgentMarket):
     def get_usd_in_token(self, x: USD) -> CollateralToken:
         return get_usd_in_token(x, self.collateral_token_contract_address_checksummed)
 
+    def have_bet_on_market_since(self, keys: APIKeys, since: timedelta) -> bool:
+        start_time = utcnow() - since
+        prev_bets = self.get_bets_made_since(
+            better_address=keys.bet_from_address, start_time=start_time
+        )
+
+        return self.id in [b.market_id for b in prev_bets]
+
     def liquidate_existing_positions(
         self,
         bet_outcome: OutcomeStr,
@@ -368,8 +380,11 @@ class OmenAgentMarket(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["OmenAgentMarket"]:
+        fetch_categorical_markets = question_type == QuestionType.CATEGORICAL
+
         return [
             OmenAgentMarket.from_data_model(m)
             for m in OmenSubgraphHandler().get_omen_markets_simple(
@@ -394,6 +409,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(
@@ -421,16 +456,19 @@ class OmenAgentMarket(AgentMarket):
 
     def store_trades(
         self,
-        traded_market: ProcessedTradedMarket | None,
+        traded_market: ProcessedMarket | None,
         keys: APIKeys,
         agent_name: str,
         web3: Web3 | None = None,
     ) -> None:
         return store_trades(
-            market_id=self.id,
+            contract=OmenAgentResultMappingContract(),
+            market_id=Web3.to_checksum_address(self.id),
+            outcomes=self.outcomes,
             traded_market=traded_market,
             keys=keys,
             agent_name=agent_name,
+            web3=web3,
         )
 
     @staticmethod
@@ -607,11 +645,10 @@ class OmenAgentMarket(AgentMarket):
         Note: this is only valid if the market instance's token pool is
         up-to-date with the smart contract.
         """
-        outcome_token_pool = check_not_none(self.outcome_token_pool)
         amount = get_buy_outcome_token_amount(
             investment_amount=self.get_in_token(bet_amount),
             outcome_index=self.get_outcome_index(outcome),
-            pool_balances=[outcome_token_pool[x] for x in self.outcomes],
+            pool_balances=[self.outcome_token_pool[x] for x in self.outcomes],
             fees=self.fees,
         )
         return amount
@@ -634,10 +671,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(
@@ -670,6 +703,26 @@ def omen_buy_outcome_tx(
     auto_deposit: bool,
     web3: Web3 | None = None,
     slippage: float = 0.01,
+) -> str:
+    return omen_buy_outcome_tx_no_retry(
+        api_keys=api_keys,
+        amount=amount,
+        market=market,
+        outcome=outcome,
+        auto_deposit=auto_deposit,
+        web3=web3,
+        slippage=slippage,
+    )
+
+
+def omen_buy_outcome_tx_no_retry(
+    api_keys: APIKeys,
+    amount: USD | CollateralToken,
+    market: OmenAgentMarket,
+    outcome: OutcomeStr,
+    auto_deposit: bool,
+    web3: Web3 | None = None,
+    slippage: float = 0.01,
 ) -> str:
     """
     Bets the given amount for the given outcome in the given market.
@@ -715,7 +768,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(
@@ -809,7 +862,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(
@@ -1057,11 +1110,11 @@ 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(
-            parent_collection_id, market.condition.id, index_set, web3=web3
+            HexBytes(parent_collection_id), market.condition.id, index_set, web3=web3
         )
         # Note that collection_id is returned as bytes, which is accepted by the contract calls downstream.
         position_id: int = conditional_token_contract.getPositionId(
@@ -1305,20 +1358,34 @@ def send_keeping_token_to_eoa_xdai(
         )
 
 
-def get_buy_outcome_token_amount(
+class BuyOutcomeResult(BaseModel):
+    outcome_tokens_received: OutcomeToken
+    new_pool_balances: list[OutcomeToken]
+
+
+def calculate_buy_outcome_token(
     investment_amount: CollateralToken,
     outcome_index: int,
     pool_balances: list[OutcomeToken],
     fees: MarketFees,
-) -> OutcomeToken:
+) -> BuyOutcomeResult:
     """
     Calculates the amount of outcome tokens received for a given investment
+    and returns the new pool balances after the purchase.
 
     Taken from https://github.com/gnosis/conditional-tokens-market-makers/blob/6814c0247c745680bb13298d4f0dd7f5b574d0db/contracts/FixedProductMarketMaker.sol#L264
     """
     if outcome_index >= len(pool_balances):
         raise ValueError("invalid outcome index")
 
+    new_pool_balances = pool_balances.copy()
+
+    if investment_amount == 0:
+        return BuyOutcomeResult(
+            outcome_tokens_received=OutcomeToken(0),
+            new_pool_balances=new_pool_balances,
+        )
+
     investment_amount_minus_fees = fees.get_after_fees(investment_amount)
     investment_amount_minus_fees_as_ot = OutcomeToken(
         investment_amount_minus_fees.value
@@ -1330,17 +1397,39 @@ def get_buy_outcome_token_amount(
     # Calculate the ending balance considering all other outcomes
     for i, pool_balance in enumerate(pool_balances):
         if i != outcome_index:
-            denominator = pool_balance + investment_amount_minus_fees_as_ot
+            new_pool_balances[i] = pool_balance + investment_amount_minus_fees_as_ot
             ending_outcome_balance = OutcomeToken(
-                (ending_outcome_balance * pool_balance / denominator)
+                (ending_outcome_balance * pool_balance / new_pool_balances[i])
             )
 
+    # Update the bought outcome's pool balance
+    new_pool_balances[outcome_index] = ending_outcome_balance
+
     if ending_outcome_balance <= 0:
         raise ValueError("must have non-zero balances")
 
-    result = (
+    outcome_tokens_received = (
         buy_token_pool_balance
         + investment_amount_minus_fees_as_ot
         - ending_outcome_balance
     )
-    return result
+
+    return BuyOutcomeResult(
+        outcome_tokens_received=outcome_tokens_received,
+        new_pool_balances=new_pool_balances,
+    )
+
+
+def get_buy_outcome_token_amount(
+    investment_amount: CollateralToken,
+    outcome_index: int,
+    pool_balances: list[OutcomeToken],
+    fees: MarketFees,
+) -> OutcomeToken:
+    result = calculate_buy_outcome_token(
+        investment_amount=investment_amount,
+        outcome_index=outcome_index,
+        pool_balances=pool_balances,
+        fees=fees,
+    )
+    return result.outcome_tokens_received

prediction_market_agent_tooling/markets/omen/omen_constants.py

@@ -1,8 +1,16 @@
 from web3 import Web3
 
+from prediction_market_agent_tooling.gtypes import OutcomeStr
+
+OMEN_TRUE_OUTCOME = OutcomeStr("Yes")
+OMEN_FALSE_OUTCOME = OutcomeStr("No")
+
 WRAPPED_XDAI_CONTRACT_ADDRESS = Web3.to_checksum_address(
     "0xe91d153e0b41518a2ce8dd3d7944fa863463a97d"
 )
 SDAI_CONTRACT_ADDRESS = Web3.to_checksum_address(
     "0xaf204776c7245bF4147c2612BF6e5972Ee483701"
 )
+METRI_SUPER_GROUP_CONTRACT_ADDRESS = Web3.to_checksum_address(
+    "0x7147A7405fCFe5CFa30c6d5363f9f357a317d082"
+)