prediction-market-agent-tooling 0.48.18__py3-none-any.whl → 0.49.1__py3-none-any.whl

prediction_market_agent_tooling/markets/agent_market.py

@@ -18,8 +18,8 @@ from prediction_market_agent_tooling.markets.data_models import (
     TokenAmount,
 )
 from prediction_market_agent_tooling.tools.utils import (
-    add_utc_timezone_validator,
     check_not_none,
+    convert_to_utc_datetime,
     should_not_happen,
     utcnow,
 )
@@ -61,10 +61,10 @@ class AgentMarket(BaseModel):
     volume: float | None  # Should be in currency of `currency` above.
 
     _add_timezone_validator_created_time = field_validator("created_time")(
-        add_utc_timezone_validator
+        convert_to_utc_datetime
     )
     _add_timezone_validator_close_time = field_validator("close_time")(
-        add_utc_timezone_validator
+        convert_to_utc_datetime
     )
 
     @field_validator("outcome_token_pool")
@@ -166,13 +166,13 @@ class AgentMarket(BaseModel):
     def liquidate_existing_positions(self, outcome: bool) -> None:
         raise NotImplementedError("Subclasses must implement this method")
 
-    def place_bet(self, outcome: bool, amount: BetAmount) -> None:
+    def place_bet(self, outcome: bool, amount: BetAmount) -> str:
         raise NotImplementedError("Subclasses must implement this method")
 
-    def buy_tokens(self, outcome: bool, amount: TokenAmount) -> None:
+    def buy_tokens(self, outcome: bool, amount: TokenAmount) -> str:
         return self.place_bet(outcome=outcome, amount=amount)
 
-    def sell_tokens(self, outcome: bool, amount: TokenAmount) -> None:
+    def sell_tokens(self, outcome: bool, amount: TokenAmount) -> str:
         raise NotImplementedError("Subclasses must implement this method")
 
     @staticmethod
@@ -281,3 +281,11 @@ class AgentMarket(BaseModel):
             raise ValueError("Outcome token pool is not available.")
 
         return self.outcome_token_pool[outcome]
+
+    @staticmethod
+    def get_user_balance(user_id: str) -> float:
+        raise NotImplementedError("Subclasses must implement this method")
+
+    @staticmethod
+    def get_user_id(api_keys: APIKeys) -> str:
+        raise NotImplementedError("Subclasses must implement this method")

prediction_market_agent_tooling/markets/data_models.py

@@ -37,6 +37,7 @@ ProfitAmount: TypeAlias = TokenAmount
 
 
 class Bet(BaseModel):
+    id: str
     amount: BetAmount
     outcome: bool
     created_time: datetime
@@ -126,3 +127,16 @@ class Trade(BaseModel):
     trade_type: TradeType
     outcome: bool
     amount: TokenAmount
+
+
+class PlacedTrade(Trade):
+    id: str | None = None
+
+    @staticmethod
+    def from_trade(trade: Trade, id: str) -> "PlacedTrade":
+        return PlacedTrade(
+            trade_type=trade.trade_type,
+            outcome=trade.outcome,
+            amount=trade.amount,
+            id=id,
+        )

prediction_market_agent_tooling/markets/manifold/api.py

@@ -110,7 +110,7 @@ def get_one_manifold_binary_market() -> ManifoldMarket:
 )
 def place_bet(
     amount: Mana, market_id: str, outcome: bool, manifold_api_key: SecretStr
-) -> None:
+) -> ManifoldBet:
     outcome_str = "YES" if outcome else "NO"
     url = f"{MANIFOLD_API_BASE_URL}/v0/bet"
     params = {
@@ -131,6 +131,7 @@ def place_bet(
             raise RuntimeError(
                 f"Placing bet failed: {response.status_code} {response.reason} {response.text}"
             )
+        return ManifoldBet.model_validate(data)
     else:
         raise Exception(
             f"Placing bet failed: {response.status_code} {response.reason} {response.text}"
@@ -209,6 +210,7 @@ def manifold_to_generic_resolved_bet(
 
     market_outcome = market.get_resolved_boolean_outcome()
     return ResolvedBet(
+        id=bet.id,
         amount=BetAmount(amount=bet.amount, currency=Currency.Mana),
         outcome=bet.get_resolved_boolean_outcome(),
         created_time=bet.createdTime,

prediction_market_agent_tooling/markets/manifold/manifold.py

@@ -49,15 +49,16 @@ class ManifoldAgentMarket(AgentMarket):
         # Manifold lowest bet is 1 Mana, so we need to ceil the result.
         return mana_type(ceil(minimum_bet_to_win(answer, amount_to_win, self)))
 
-    def place_bet(self, outcome: bool, amount: BetAmount) -> None:
+    def place_bet(self, outcome: bool, amount: BetAmount) -> str:
         if amount.currency != self.currency:
             raise ValueError(f"Manifold bets are made in Mana. Got {amount.currency}.")
-        place_bet(
+        bet = place_bet(
             amount=Mana(amount.amount),
             market_id=self.id,
             outcome=outcome,
             manifold_api_key=APIKeys().manifold_api_key,
         )
+        return bet.id
 
     @staticmethod
     def from_data_model(model: FullManifoldMarket) -> "ManifoldAgentMarket":
@@ -119,3 +120,7 @@ class ManifoldAgentMarket(AgentMarket):
     @classmethod
     def get_user_url(cls, keys: APIKeys) -> str:
         return get_authenticated_user(keys.manifold_api_key.get_secret_value()).url
+
+    @staticmethod
+    def get_user_id(api_keys: APIKeys) -> str:
+        return api_keys.manifold_user_id

prediction_market_agent_tooling/markets/metaculus/metaculus.py

@@ -1,6 +1,7 @@
 import typing as t
 from datetime import datetime
 
+from prediction_market_agent_tooling.config import APIKeys
 from prediction_market_agent_tooling.gtypes import Probability
 from prediction_market_agent_tooling.markets.agent_market import (
     AgentMarket,
@@ -99,8 +100,12 @@ class MetaculusAgentMarket(AgentMarket):
 
             if len(all_questions) >= limit:
                 break
-        return [MetaculusAgentMarket.from_data_model(q) for q in all_questions]
+        return [MetaculusAgentMarket.from_data_model(q) for q in all_questions[:limit]]
 
     def submit_prediction(self, p_yes: Probability, reasoning: str) -> None:
         make_prediction(self.id, p_yes)
         post_question_comment(self.id, reasoning)
+
+    @staticmethod
+    def get_user_id(api_keys: APIKeys) -> str:
+        return str(api_keys.metaculus_user_id)

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,13 +377,103 @@ 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
 
 
 class OmenBet(BaseModel):
-    id: HexAddress
+    id: HexAddress  # A concatenation of: FPMM contract ID, trader ID and nonce. See https://github.com/protofire/omen-subgraph/blob/f92bbfb6fa31ed9cd5985c416a26a2f640837d8b/src/FixedProductMarketMakerMapping.ts#L109
     title: str
     collateralToken: HexAddress
     outcomeTokenMarginalPrice: xDai
@@ -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:
@@ -431,6 +522,9 @@ class OmenBet(BaseModel):
 
     def to_bet(self) -> Bet:
         return Bet(
+            id=str(
+                self.transactionHash
+            ),  # 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=BetAmount(amount=self.collateralAmountUSD, currency=Currency.xDai),
             outcome=self.boolean_outcome,
             created_time=self.creation_datetime,
@@ -445,6 +539,9 @@ class OmenBet(BaseModel):
             )
 
         return ResolvedBet(
+            id=str(
+                self.transactionHash
+            ),  # 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=BetAmount(amount=self.collateralAmountUSD, currency=Currency.xDai),
             outcome=self.boolean_outcome,
             created_time=self.creation_datetime,
@@ -527,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",
+    )