prediction-market-agent-tooling 0.49.0__py3-none-any.whl → 0.49.2__py3-none-any.whl

prediction_market_agent_tooling/markets/omen/data_models.py

@@ -1,7 +1,8 @@
 import typing as t
 from datetime import datetime
 
-from pydantic import BaseModel
+import pytz
+from pydantic import BaseModel, ConfigDict, Field, computed_field
 from web3 import Web3
 
 from prediction_market_agent_tooling.gtypes import (
@@ -13,6 +14,7 @@ from prediction_market_agent_tooling.gtypes import (
     OmenOutcomeToken,
     Probability,
     Wei,
+    wei_type,
     xDai,
 )
 from prediction_market_agent_tooling.markets.data_models import (
@@ -37,6 +39,7 @@ INVALID_ANSWER_HEX_BYTES = HexBytes(INVALID_ANSWER)
 INVALID_ANSWER_STR = HexStr(INVALID_ANSWER_HEX_BYTES.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.
 
 
 def get_boolean_outcome(outcome_str: str) -> bool:
@@ -207,8 +210,6 @@ class OmenMarket(BaseModel):
     creationTimestamp: int
     condition: Condition
     question: Question
-    lastActiveDay: int
-    lastActiveHour: int
 
     @property
     def openingTimestamp(self) -> int:
@@ -218,7 +219,7 @@ class OmenMarket(BaseModel):
 
     @property
     def opening_datetime(self) -> datetime:
-        return datetime.fromtimestamp(self.openingTimestamp)
+        return datetime.fromtimestamp(self.openingTimestamp, tz=pytz.UTC)
 
     @property
     def close_time(self) -> datetime:
@@ -376,6 +377,96 @@ class OmenMarket(BaseModel):
     def url(self) -> str:
         return f"{PRESAGIO_BASE_URL}/markets?id={self.id}"
 
+    @staticmethod
+    def from_created_market(model: "CreatedMarket") -> "OmenMarket":
+        """
+        OmenMarket is meant to be retrieved from subgraph, however in tests against local chain it's very handy to create it out of `CreatedMarket`,
+        which is collection of events that are emitted during the market creation in omen_create_market_tx function.
+        """
+        if len(model.market_event.conditionIds) != 1:
+            raise ValueError(
+                f"Unexpected number of conditions: {len(model.market_event.conditionIds)}"
+            )
+        outcome_token_amounts = model.funding_event.outcome_token_amounts
+        return OmenMarket(
+            id=HexAddress(
+                HexStr(model.market_event.fixedProductMarketMaker.lower())
+            ),  # Lowering to be identical with subgraph's output.
+            title=model.question_event.parsed_question.question,
+            creator=HexAddress(
+                HexStr(model.market_event.creator.lower())
+            ),  # Lowering to be identical with subgraph's output.
+            category=model.question_event.parsed_question.category,
+            collateralVolume=Wei(0),  # No volume possible yet.
+            liquidityParameter=calculate_liquidity_parameter(outcome_token_amounts),
+            usdVolume=USD(0),  # No volume possible yet.
+            fee=model.fee,
+            collateralToken=HexAddress(
+                HexStr(model.market_event.collateralToken.lower())
+            ),  # Lowering to be identical with subgraph's output.
+            outcomes=model.question_event.parsed_question.outcomes,
+            outcomeTokenAmounts=outcome_token_amounts,
+            outcomeTokenMarginalPrices=calculate_marginal_prices(outcome_token_amounts),
+            answerFinalizedTimestamp=None,  # It's a fresh market.
+            currentAnswer=None,  # It's a fresh market.
+            creationTimestamp=model.market_creation_timestamp,
+            condition=Condition(
+                id=model.market_event.conditionIds[0],
+                outcomeSlotCount=len(model.question_event.parsed_question.outcomes),
+            ),
+            question=Question(
+                id=model.question_event.question_id,
+                title=model.question_event.parsed_question.question,
+                data=model.question_event.question,  # Question in the event holds the "raw" data.
+                templateId=model.question_event.template_id,
+                outcomes=model.question_event.parsed_question.outcomes,
+                isPendingArbitration=False,  # Can not be, it's a fresh market.
+                openingTimestamp=model.question_event.opening_ts,
+                answerFinalizedTimestamp=None,  # It's a new one, can not be.
+                currentAnswer=None,  # It's a new one, no answer yet.
+            ),
+        )
+
+
+def calculate_liquidity_parameter(
+    outcome_token_amounts: list[OmenOutcomeToken],
+) -> Wei:
+    """
+    Converted to Python from https://github.com/protofire/omen-subgraph/blob/f92bbfb6fa31ed9cd5985c416a26a2f640837d8b/src/utils/fpmm.ts#L171.
+    """
+    amounts_product = 1.0
+    for amount in outcome_token_amounts:
+        amounts_product *= amount
+    n = len(outcome_token_amounts)
+    liquidity_parameter = amounts_product ** (1.0 / n)
+    return wei_type(liquidity_parameter)
+
+
+def calculate_marginal_prices(
+    outcome_token_amounts: list[OmenOutcomeToken],
+) -> list[xDai] | None:
+    """
+    Converted to Python from https://github.com/protofire/omen-subgraph/blob/f92bbfb6fa31ed9cd5985c416a26a2f640837d8b/src/utils/fpmm.ts#L197.
+    """
+    all_non_zero = all(x != 0 for x in outcome_token_amounts)
+    if not all_non_zero:
+        return None
+
+    n_outcomes = len(outcome_token_amounts)
+    weights = []
+
+    for i in range(n_outcomes):
+        weight = 1.0
+        for j in range(n_outcomes):
+            if i != j:
+                weight *= outcome_token_amounts[j]
+        weights.append(weight)
+
+    sum_weights = sum(weights)
+
+    marginal_prices = [weights[i] / sum_weights for i in range(n_outcomes)]
+    return [xDai(mp) for mp in marginal_prices]
+
 
 class OmenBetCreator(BaseModel):
     id: HexAddress
@@ -400,7 +491,7 @@ class OmenBet(BaseModel):
 
     @property
     def creation_datetime(self) -> datetime:
-        return datetime.fromtimestamp(self.creationTimestamp)
+        return datetime.fromtimestamp(self.creationTimestamp, tz=pytz.UTC)
 
     @property
     def boolean_outcome(self) -> bool:
@@ -533,3 +624,147 @@ class RealityAnswers(BaseModel):
 
 class RealityAnswersResponse(BaseModel):
     data: RealityAnswers
+
+
+def format_realitio_question(
+    question: str,
+    outcomes: list[str],
+    category: str,
+    language: str,
+    template_id: int,
+) -> str:
+    """If you add a new template id here, also add to the parsing function below."""
+    if template_id == 2:
+        return "␟".join(
+            [
+                question,
+                ",".join(f'"{o}"' for o in outcomes),
+                category,
+                language,
+            ]
+        )
+
+    raise ValueError(f"Unsupported template id {template_id}.")
+
+
+def parse_realitio_question(question_raw: str, template_id: int) -> "ParsedQuestion":
+    """If you add a new template id here, also add to the encoding function above."""
+    if template_id == 2:
+        question, outcomes_raw, category, language = question_raw.split("␟")
+        outcomes = [o.strip('"') for o in outcomes_raw.split(",")]
+        return ParsedQuestion(
+            question=question, outcomes=outcomes, category=category, language=language
+        )
+
+    raise ValueError(f"Unsupported template id {template_id}.")
+
+
+class ParsedQuestion(BaseModel):
+    question: str
+    outcomes: list[str]
+    language: str
+    category: str
+
+
+class RealitioLogNewQuestionEvent(BaseModel):
+    question_id: HexBytes
+    user: HexAddress
+    template_id: int
+    question: str  # Be aware, this is question in format of format_realitio_question function, it's raw data.
+    content_hash: HexBytes
+    arbitrator: HexAddress
+    timeout: int
+    opening_ts: int
+    nonce: int
+    created: int
+
+    @property
+    def user_checksummed(self) -> ChecksumAddress:
+        return Web3.to_checksum_address(self.user)
+
+    @property
+    def parsed_question(self) -> ParsedQuestion:
+        return parse_realitio_question(
+            question_raw=self.question, template_id=self.template_id
+        )
+
+
+class OmenFixedProductMarketMakerCreationEvent(BaseModel):
+    creator: HexAddress
+    fixedProductMarketMaker: HexAddress
+    conditionalTokens: HexAddress
+    collateralToken: HexAddress
+    conditionIds: list[HexBytes]
+    fee: int
+
+    @property
+    def creator_checksummed(self) -> ChecksumAddress:
+        return Web3.to_checksum_address(self.creator)
+
+    @property
+    def fixed_product_market_maker_checksummed(self) -> ChecksumAddress:
+        return Web3.to_checksum_address(self.fixedProductMarketMaker)
+
+    @property
+    def conditional_tokens_checksummed(self) -> ChecksumAddress:
+        return Web3.to_checksum_address(self.conditionalTokens)
+
+    @property
+    def collateral_token_checksummed(self) -> ChecksumAddress:
+        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[OmenOutcomeToken]
+    sharesMinted: Wei
+
+    @property
+    def outcome_token_amounts(self) -> list[OmenOutcomeToken]:
+        # Just renaming so we remember what it is.
+        return self.amountsAdded
+
+
+class CreatedMarket(BaseModel):
+    market_creation_timestamp: int
+    market_event: OmenFixedProductMarketMakerCreationEvent
+    funding_event: FPMMFundingAddedEvent
+    condition_id: HexBytes
+    question_event: RealitioLogNewQuestionEvent
+    condition_event: ConditionPreparationEvent | None
+    initial_funds: Wei
+    fee: Wei
+    distribution_hint: list[OmenOutcomeToken] | None
+
+
+class ContractPrediction(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    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")
+
+    @computed_field  # type: ignore[prop-decorator] # Mypy issue: https://github.com/python/mypy/issues/14461
+    @property
+    def publisher_checksummed(self) -> ChecksumAddress:
+        return Web3.to_checksum_address(self.publisher)
+
+    @staticmethod
+    def from_tuple(values: tuple[t.Any]) -> "ContractPrediction":
+        data = {k: v for k, v in zip(ContractPrediction.model_fields.keys(), values)}
+        return ContractPrediction.model_validate(data)
+
+
+class IPFSAgentResult(BaseModel):
+    reasoning: str
+
+    model_config = ConfigDict(
+        extra="forbid",
+    )

prediction_market_agent_tooling/markets/omen/omen.py

@@ -1,16 +1,16 @@
 import sys
 import typing as t
-from datetime import datetime
+from datetime import datetime, timedelta
 
 import tenacity
 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 (
     ChecksumAddress,
     HexAddress,
     HexStr,
+    OmenOutcomeToken,
     OutcomeStr,
     Probability,
     Wei,
@@ -37,6 +37,8 @@ from prediction_market_agent_tooling.markets.omen.data_models import (
     OMEN_TRUE_OUTCOME,
     PRESAGIO_BASE_URL,
     Condition,
+    ConditionPreparationEvent,
+    CreatedMarket,
     OmenBet,
     OmenMarket,
     OmenUserPosition,
@@ -44,7 +46,8 @@ from prediction_market_agent_tooling.markets.omen.data_models import (
     get_boolean_outcome,
 )
 from prediction_market_agent_tooling.markets.omen.omen_contracts import (
-    OMEN_DEFAULT_MARKET_FEE,
+    OMEN_DEFAULT_MARKET_FEE_PERC,
+    REALITY_DEFAULT_FINALIZATION_TIMEOUT,
     Arbitrator,
     OmenConditionalTokenContract,
     OmenFixedProductMarketMakerContract,
@@ -52,6 +55,7 @@ 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,
@@ -71,6 +75,7 @@ from prediction_market_agent_tooling.tools.utils import (
 )
 from prediction_market_agent_tooling.tools.web3_utils import (
     add_fraction,
+    get_receipt_block_timestamp,
     remove_fraction,
     wei_to_xdai,
     xdai_to_wei,
@@ -325,6 +330,10 @@ class OmenAgentMarket(AgentMarket):
 
         omen_redeem_full_position_tx(api_keys=api_keys, market=self)
 
+    @staticmethod
+    def from_created_market(model: "CreatedMarket") -> "OmenAgentMarket":
+        return OmenAgentMarket.from_data_model(OmenMarket.from_created_market(model))
+
     @staticmethod
     def from_data_model(model: OmenMarket) -> "OmenAgentMarket":
         return OmenAgentMarket(
@@ -674,7 +683,7 @@ def omen_buy_outcome_tx(
     amount_wei = xdai_to_wei(amount)
 
     market_contract: OmenFixedProductMarketMakerContract = market.get_contract()
-    collateral_token_contract = market_contract.get_collateral_token_contract()
+    collateral_token_contract = market_contract.get_collateral_token_contract(web3)
 
     # In case of ERC4626, obtained (for example) sDai out of xDai could be lower than the `amount_wei`, so we need to handle it.
     amount_wei_to_buy = collateral_token_contract.get_in_shares(amount_wei, web3)
@@ -751,7 +760,7 @@ def omen_sell_outcome_tx(
 
     market_contract: OmenFixedProductMarketMakerContract = market.get_contract()
     conditional_token_contract = OmenConditionalTokenContract()
-    collateral_token_contract = market_contract.get_collateral_token_contract()
+    collateral_token_contract = market_contract.get_collateral_token_contract(web3)
 
     # Verify, that markets uses conditional tokens that we expect.
     if (
@@ -832,10 +841,13 @@ def omen_create_market_tx(
     language: str,
     outcomes: list[str],
     auto_deposit: bool,
-    fee: float = OMEN_DEFAULT_MARKET_FEE,
+    finalization_timeout: timedelta = REALITY_DEFAULT_FINALIZATION_TIMEOUT,
+    fee_perc: float = OMEN_DEFAULT_MARKET_FEE_PERC,
+    distribution_hint: list[OmenOutcomeToken] | None = None,
     collateral_token_address: ChecksumAddress = WrappedxDaiContract().address,
+    arbitrator: Arbitrator = Arbitrator.KLEROS_31_JURORS_WITH_APPEAL,
     web3: Web3 | None = None,
-) -> ChecksumAddress:
+) -> CreatedMarket:
     """
     Based on omen-exchange TypeScript code: https://github.com/protofire/omen-exchange/blob/b0b9a3e71b415d6becf21fe428e1c4fc0dad2e80/app/src/services/cpk/cpk.ts#L308
     """
@@ -873,28 +885,30 @@ def omen_create_market_tx(
         )
 
     # Create the question on Realitio.
-    question_id = realitio_contract.askQuestion(
+    question_event = realitio_contract.askQuestion(
         api_keys=api_keys,
         question=question,
         category=category,
         outcomes=outcomes,
         language=language,
-        arbitrator=Arbitrator.KLEROS,
+        arbitrator=arbitrator,
         opening=closing_time,  # The question is opened at the closing time of the market.
+        timeout=finalization_timeout,
         web3=web3,
     )
 
     # Construct the condition id.
+    cond_event: ConditionPreparationEvent | None = None
     condition_id = conditional_token_contract.getConditionId(
-        question_id=question_id,
+        question_id=question_event.question_id,
         oracle_address=oracle_contract.address,
         outcomes_slot_count=len(outcomes),
         web3=web3,
     )
     if not conditional_token_contract.does_condition_exists(condition_id, web3=web3):
-        conditional_token_contract.prepareCondition(
+        cond_event = conditional_token_contract.prepareCondition(
             api_keys=api_keys,
-            question_id=question_id,
+            question_id=question_event.question_id,
             oracle_address=oracle_contract.address,
             outcomes_slot_count=len(outcomes),
             web3=web3,
@@ -914,10 +928,16 @@ def omen_create_market_tx(
     )
 
     # Create the market.
-    create_market_receipt_tx = factory_contract.create2FixedProductMarketMaker(
+    fee = xdai_to_wei(xdai_type(fee_perc))
+    (
+        market_event,
+        funding_event,
+        receipt_tx,
+    ) = factory_contract.create2FixedProductMarketMaker(
         api_keys=api_keys,
         condition_id=condition_id,
         fee=fee,
+        distribution_hint=distribution_hint,
         initial_funds_wei=initial_funds_in_shares,
         collateral_token_address=collateral_token_contract.address,
         web3=web3,
@@ -928,10 +948,17 @@ def omen_create_market_tx(
     # but address of stakingRewardsFactoryAddress on xDai/Gnosis is 0x0000000000000000000000000000000000000000,
     # so skipping it here.
 
-    market_address = create_market_receipt_tx["logs"][-1][
-        "address"
-    ]  # The market address is available in the last emitted log, in the address field.
-    return market_address
+    return CreatedMarket(
+        market_creation_timestamp=get_receipt_block_timestamp(receipt_tx, web3),
+        market_event=market_event,
+        funding_event=funding_event,
+        condition_id=condition_id,
+        question_event=question_event,
+        condition_event=cond_event,
+        initial_funds=initial_funds_wei,
+        fee=fee,
+        distribution_hint=distribution_hint,
+    )
 
 
 def omen_fund_market_tx(
@@ -960,10 +987,6 @@ def omen_fund_market_tx(
     market_contract.addFunding(api_keys, amount_to_fund, web3=web3)
 
 
-def build_parent_collection_id() -> HexStr:
-    return HASH_ZERO  # Taken from Olas
-
-
 def omen_redeem_full_position_tx(
     api_keys: APIKeys,
     market: OmenAgentMarket,
@@ -985,8 +1008,6 @@ def omen_redeem_full_position_tx(
             f"Market {market.id} uses conditional token that we didn't expect, {market_contract.conditionalTokens()} != {conditional_token_contract.address=}"
         )
 
-    parent_collection_id = build_parent_collection_id()
-
     if not market.is_resolved():
         logger.debug("Cannot redeem winnings if market is not yet resolved. Exiting.")
         return
@@ -1007,7 +1028,6 @@ def omen_redeem_full_position_tx(
         api_keys=api_keys,
         collateral_token_address=market.collateral_token_contract_address_checksummed,
         condition_id=market.condition.id,
-        parent_collection_id=parent_collection_id,
         index_sets=market.condition.index_sets,
         web3=web3,
     )
@@ -1142,7 +1162,6 @@ def redeem_from_all_user_positions(
             api_keys=api_keys,
             collateral_token_address=user_position.position.collateral_token_contract_address_checksummed,
             condition_id=condition_id,
-            parent_collection_id=build_parent_collection_id(),
             index_sets=user_position.position.indexSets,
             web3=web3,
         )