prediction-market-agent-tooling 0.14.1__py3-none-any.whl → 0.15.0__py3-none-any.whl

prediction_market_agent_tooling/markets/omen/data_models.py

@@ -21,7 +21,10 @@ from prediction_market_agent_tooling.markets.data_models import (
     Resolution,
     ResolvedBet,
 )
-from prediction_market_agent_tooling.tools.utils import check_not_none
+from prediction_market_agent_tooling.tools.utils import (
+    check_not_none,
+    should_not_happen,
+)
 from prediction_market_agent_tooling.tools.web3_utils import wei_to_xdai
 
 OMEN_TRUE_OUTCOME = "Yes"
@@ -154,6 +157,8 @@ class OmenMarket(BaseModel):
     creationTimestamp: int
     condition: Condition
     question: Question
+    lastActiveDay: int
+    lastActiveHour: int
 
     @property
     def openingTimestamp(self) -> int:
@@ -241,11 +246,19 @@ class OmenMarket(BaseModel):
         )
 
     @property
-    def p_no(self) -> Probability:
-        return Probability(1 - self.p_yes)
+    def yes_index(self) -> int:
+        return self.outcomes.index(OMEN_TRUE_OUTCOME)
+
+    @property
+    def no_index(self) -> int:
+        return self.outcomes.index(OMEN_FALSE_OUTCOME)
 
     @property
-    def p_yes(self) -> Probability:
+    def current_p_no(self) -> Probability:
+        return Probability(1 - self.current_p_yes)
+
+    @property
+    def current_p_yes(self) -> Probability:
         """
         Calculate the probability of the outcomes from the relative token amounts.
 
@@ -257,21 +270,29 @@ class OmenMarket(BaseModel):
         the the lower the price of that token, and therefore the lower the
         probability of that outcome.
         """
-        if self.outcomeTokenAmounts is None:
-            raise ValueError(
-                f"Market with title {self.title} has no outcomeTokenAmounts."
-            )
         if len(self.outcomeTokenAmounts) != 2:
             raise ValueError(
                 f"Market with title {self.title} has {len(self.outcomeTokenAmounts)} outcomes."
             )
-        true_index = self.outcomes.index(OMEN_TRUE_OUTCOME)
 
         if sum(self.outcomeTokenAmounts) == 0:
-            return Probability(0.5)
+            # If there are no outcome tokens, it should mean that market is closed and without liquidity, so we need to infer the probabilities based on the answer.
+            return (
+                Probability(1.0)
+                if self.yes_index == self.answer_index
+                else (
+                    Probability(0.0)
+                    if self.no_index == self.answer_index
+                    else (
+                        Probability(0.5)
+                        if not self.has_valid_answer  # Invalid market or closed market without resolution.
+                        else should_not_happen("Unknown condition.")
+                    )
+                )
+            )
 
         return Probability(
-            1 - self.outcomeTokenAmounts[true_index] / sum(self.outcomeTokenAmounts)
+            1 - self.outcomeTokenAmounts[self.yes_index] / sum(self.outcomeTokenAmounts)
         )
 
     def __repr__(self) -> str:
@@ -335,6 +356,16 @@ class OmenBet(BaseModel):
     def boolean_outcome(self) -> bool:
         return get_boolean_outcome(self.fpmm.outcomes[self.outcomeIndex])
 
+    @property
+    def old_probability(self) -> Probability:
+        # Old marginal price is the probability of the outcome before placing this bet.
+        return Probability(float(self.oldOutcomeTokenMarginalPrice))
+
+    @property
+    def probability(self) -> Probability:
+        # Marginal price is the probability of the outcome after placing this bet.
+        return Probability(float(self.outcomeTokenMarginalPrice))
+
     def get_profit(self) -> ProfitAmount:
         bet_amount_xdai = wei_to_xdai(self.collateralAmount)
         profit = (

prediction_market_agent_tooling/markets/omen/omen.py

@@ -6,13 +6,13 @@ from loguru import logger
 from web3 import Web3
 from web3.constants import HASH_ZERO
 
-from prediction_market_agent_tooling.config import APIKeys
+from prediction_market_agent_tooling.config import APIKeys, PrivateCredentials
 from prediction_market_agent_tooling.gtypes import (
     ChecksumAddress,
     HexAddress,
     HexStr,
     OutcomeStr,
-    PrivateKey,
+    Probability,
     Wei,
     wei_type,
     xDai,
@@ -56,7 +56,6 @@ from prediction_market_agent_tooling.tools.hexbytes_custom import HexBytes
 from prediction_market_agent_tooling.tools.utils import check_not_none
 from prediction_market_agent_tooling.tools.web3_utils import (
     add_fraction,
-    private_key_to_public_key,
     remove_fraction,
     wei_to_xdai,
     xdai_to_wei,
@@ -85,6 +84,38 @@ class OmenAgentMarket(AgentMarket):
         "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
     )
 
+    _binary_market_p_yes_history: list[Probability] | None = None
+
+    @property
+    def yes_index(self) -> int:
+        return self.outcomes.index(OMEN_TRUE_OUTCOME)
+
+    @property
+    def no_index(self) -> int:
+        return self.outcomes.index(OMEN_FALSE_OUTCOME)
+
+    def get_p_yes_history_cached(self) -> list[Probability]:
+        if self._binary_market_p_yes_history is None:
+            self._binary_market_p_yes_history = get_binary_market_p_yes_history(self)
+        return self._binary_market_p_yes_history
+
+    def get_last_trade_p_yes(self) -> Probability | None:
+        """On Omen, probablities converge after the resolution, so we need to get market's predicted probability from the trade history."""
+        return (
+            self.get_p_yes_history_cached()[-1]
+            if self.get_p_yes_history_cached()
+            else None
+        )
+
+    def get_last_trade_p_no(self) -> Probability | None:
+        """On Omen, probablities converge after the resolution, so we need to get market's predicted probability from the trade history."""
+        last_trade_p_yes = self.get_last_trade_p_yes()
+        return (
+            Probability(1.0 - last_trade_p_yes)
+            if last_trade_p_yes is not None
+            else None
+        )
+
     def get_liquidity(self) -> Wei:
         return self.get_contract().totalSupply()
 
@@ -95,27 +126,34 @@ class OmenAgentMarket(AgentMarket):
         return BetAmount(amount=0.00001, currency=self.currency)
 
     def place_bet(
-        self, outcome: bool, amount: BetAmount, omen_auto_deposit: bool = True
+        self,
+        outcome: bool,
+        amount: BetAmount,
+        omen_auto_deposit: bool = True,
+        web3: Web3 | None = None,
     ) -> None:
         if amount.currency != self.currency:
             raise ValueError(f"Omen bets are made in xDai. Got {amount.currency}.")
         amount_xdai = xDai(amount.amount)
         keys = APIKeys()
+        private_credentials = PrivateCredentials.from_api_keys(keys)
         binary_omen_buy_outcome_tx(
+            private_credentials=private_credentials,
             amount=amount_xdai,
-            from_private_key=keys.bet_from_private_key,
             market=self,
             binary_outcome=outcome,
             auto_deposit=omen_auto_deposit,
+            web3=web3,
         )
 
     def sell_tokens(
         self, outcome: bool, amount: TokenAmount, auto_withdraw: bool = True
     ) -> None:
         keys = APIKeys()
+        private_credentials = PrivateCredentials.from_api_keys(keys)
         binary_omen_sell_outcome_tx(
+            private_credentials=private_credentials,
             amount=xDai(amount.amount),
-            from_private_key=keys.bet_from_private_key,
             market=self,
             binary_outcome=outcome,
             auto_withdraw=auto_withdraw,
@@ -165,8 +203,11 @@ class OmenAgentMarket(AgentMarket):
         )
         return len(user_positions) > 0
 
-    def redeem_positions(self, for_private_key: PrivateKey) -> None:
-        for_public_key = private_key_to_public_key(for_private_key)
+    def redeem_positions(
+        self,
+        private_credentials: PrivateCredentials,
+    ) -> None:
+        for_public_key = private_credentials.public_key
         market_is_redeemable = self.market_redeemable_by(user=for_public_key)
         if not market_is_redeemable:
             logger.debug(
@@ -174,7 +215,9 @@ class OmenAgentMarket(AgentMarket):
             )
             return None
 
-        omen_redeem_full_position_tx(market=self, from_private_key=for_private_key)
+        omen_redeem_full_position_tx(
+            private_credentials=private_credentials, market=self
+        )
 
     @staticmethod
     def from_data_model(model: OmenMarket) -> "OmenAgentMarket":
@@ -188,7 +231,7 @@ class OmenAgentMarket(AgentMarket):
             resolution=model.get_resolution_enum(),
             created_time=model.creation_datetime,
             finalized_time=model.finalized_datetime,
-            p_yes=model.p_yes,
+            current_p_yes=model.current_p_yes,
             condition=model.condition,
             url=model.url,
             volume=wei_to_xdai(model.collateralVolume),
@@ -222,9 +265,11 @@ class OmenAgentMarket(AgentMarket):
             )
         )
 
-    def get_contract(self) -> OmenFixedProductMarketMakerContract:
+    def get_contract(
+        self,
+    ) -> OmenFixedProductMarketMakerContract:
         return OmenFixedProductMarketMakerContract(
-            address=self.market_maker_contract_address_checksummed
+            address=self.market_maker_contract_address_checksummed,
         )
 
     def get_index_set(self, outcome: str) -> int:
@@ -238,10 +283,12 @@ class OmenAgentMarket(AgentMarket):
             cls.get_outcome_str(cls.index_set_to_outcome_index(index_set))
         )
 
-    def get_token_balance(self, user_id: str, outcome: str) -> TokenAmount:
+    def get_token_balance(
+        self, user_id: str, outcome: str, web3: Web3 | None = None
+    ) -> TokenAmount:
         index_set = self.get_index_set(outcome)
         balances = get_conditional_tokens_balance_for_market(
-            self, Web3.to_checksum_address(user_id)
+            self, Web3.to_checksum_address(user_id), web3=web3
         )
         return TokenAmount(
             amount=wei_to_xdai(balances[index_set]),
@@ -309,72 +356,79 @@ def pick_binary_market(
 
 
 def omen_buy_outcome_tx(
+    private_credentials: PrivateCredentials,
     amount: xDai,
-    from_private_key: PrivateKey,
     market: OmenAgentMarket,
     outcome: str,
     auto_deposit: bool,
+    web3: Web3 | None = None,
 ) -> None:
     """
     Bets the given amount of xDai for the given outcome in the given market.
     """
     amount_wei = xdai_to_wei(amount)
-    from_address_checksummed = private_key_to_public_key(from_private_key)
+    from_address_checksummed = private_credentials.public_key
 
     market_contract: OmenFixedProductMarketMakerContract = market.get_contract()
+
     collateral_token_contract = OmenCollateralTokenContract()
 
     # Get the index of the outcome we want to buy.
     outcome_index: int = market.get_outcome_index(outcome)
 
     # Calculate the amount of shares we will get for the given investment amount.
-    expected_shares = market_contract.calcBuyAmount(amount_wei, outcome_index)
+    expected_shares = market_contract.calcBuyAmount(
+        amount_wei, outcome_index, web3=web3
+    )
     # Allow 1% slippage.
     expected_shares = remove_fraction(expected_shares, 0.01)
     # Approve the market maker to withdraw our collateral token.
     collateral_token_contract.approve(
+        private_credentials=private_credentials,
         for_address=market_contract.address,
         amount_wei=amount_wei,
-        from_private_key=from_private_key,
+        web3=web3,
     )
     # Deposit xDai to the collateral token,
     # this can be skipped, if we know we already have enough collateral tokens.
     collateral_token_balance = collateral_token_contract.balanceOf(
-        for_address=from_address_checksummed,
+        for_address=from_address_checksummed, web3=web3
     )
     if auto_deposit and collateral_token_balance < amount_wei:
         collateral_token_contract.deposit(
-            amount_wei=amount_wei,
-            from_private_key=from_private_key,
+            private_credentials=private_credentials, amount_wei=amount_wei, web3=web3
         )
     # Buy shares using the deposited xDai in the collateral token.
     market_contract.buy(
+        private_credentials=private_credentials,
         amount_wei=amount_wei,
         outcome_index=outcome_index,
         min_outcome_tokens_to_buy=expected_shares,
-        from_private_key=from_private_key,
+        web3=web3,
     )
 
 
 def binary_omen_buy_outcome_tx(
+    private_credentials: PrivateCredentials,
     amount: xDai,
-    from_private_key: PrivateKey,
     market: OmenAgentMarket,
     binary_outcome: bool,
     auto_deposit: bool,
+    web3: Web3 | None = None,
 ) -> None:
     omen_buy_outcome_tx(
+        private_credentials=private_credentials,
         amount=amount,
-        from_private_key=from_private_key,
         market=market,
         outcome=OMEN_TRUE_OUTCOME if binary_outcome else OMEN_FALSE_OUTCOME,
         auto_deposit=auto_deposit,
+        web3=web3,
     )
 
 
 def omen_sell_outcome_tx(
+    private_credentials: PrivateCredentials,
     amount: xDai,  # The xDai value of shares to sell.
-    from_private_key: PrivateKey,
     market: OmenAgentMarket,
     outcome: str,
     auto_withdraw: bool,
@@ -410,35 +464,35 @@ def omen_sell_outcome_tx(
 
     # Approve the market maker to move our (all) conditional tokens.
     conditional_token_contract.setApprovalForAll(
+        private_credentials=private_credentials,
         for_address=market_contract.address,
         approve=True,
-        from_private_key=from_private_key,
     )
     # Sell the shares.
     market_contract.sell(
+        private_credentials,
         amount_wei,
         outcome_index,
         max_outcome_tokens_to_sell,
-        from_private_key,
     )
     if auto_withdraw:
         # Optionally, withdraw from the collateral token back to the `from_address` wallet.
         collateral_token.withdraw(
+            private_credentials=private_credentials,
             amount_wei=amount_wei,
-            from_private_key=from_private_key,
         )
 
 
 def binary_omen_sell_outcome_tx(
+    private_credentials: PrivateCredentials,
     amount: xDai,
-    from_private_key: PrivateKey,
     market: OmenAgentMarket,
     binary_outcome: bool,
     auto_withdraw: bool,
 ) -> None:
     omen_sell_outcome_tx(
+        private_credentials=private_credentials,
         amount=amount,
-        from_private_key=from_private_key,
         market=market,
         outcome=OMEN_TRUE_OUTCOME if binary_outcome else OMEN_FALSE_OUTCOME,
         auto_withdraw=auto_withdraw,
@@ -446,12 +500,12 @@ def binary_omen_sell_outcome_tx(
 
 
 def omen_create_market_tx(
+    private_credentials: PrivateCredentials,
     initial_funds: xDai,
     question: str,
     closing_time: datetime,
     category: str,
     language: str,
-    from_private_key: PrivateKey,
     outcomes: list[str],
     auto_deposit: bool,
     fee: float = OMEN_DEFAULT_MARKET_FEE,
@@ -459,7 +513,7 @@ def omen_create_market_tx(
     """
     Based on omen-exchange TypeScript code: https://github.com/protofire/omen-exchange/blob/b0b9a3e71b415d6becf21fe428e1c4fc0dad2e80/app/src/services/cpk/cpk.ts#L308
     """
-    from_address = private_key_to_public_key(from_private_key)
+    from_address = private_credentials.public_key
     initial_funds_wei = xdai_to_wei(initial_funds)
 
     realitio_contract = OmenRealitioContract()
@@ -482,9 +536,9 @@ def omen_create_market_tx(
 
     # Approve the market maker to withdraw our collateral token.
     collateral_token_contract.approve(
+        private_credentials=private_credentials,
         for_address=factory_contract.address,
         amount_wei=initial_funds_wei,
-        from_private_key=from_private_key,
     )
 
     # Deposit xDai to the collateral token,
@@ -497,17 +551,17 @@ def omen_create_market_tx(
         and initial_funds_wei > 0
         and collateral_token_balance < initial_funds_wei
     ):
-        collateral_token_contract.deposit(initial_funds_wei, from_private_key)
+        collateral_token_contract.deposit(private_credentials, initial_funds_wei)
 
     # Create the question on Realitio.
     question_id = realitio_contract.askQuestion(
+        private_credentials=private_credentials,
         question=question,
         category=category,
         outcomes=outcomes,
         language=language,
         arbitrator=Arbitrator.KLEROS,
         opening=closing_time,  # The question is opened at the closing time of the market.
-        from_private_key=from_private_key,
     )
 
     # Construct the condition id.
@@ -518,15 +572,15 @@ def omen_create_market_tx(
     )
     if not conditional_token_contract.does_condition_exists(condition_id):
         conditional_token_contract.prepareCondition(
+            private_credentials=private_credentials,
             question_id=question_id,
             oracle_address=oracle_contract.address,
             outcomes_slot_count=len(outcomes),
-            from_private_key=from_private_key,
         )
 
     # Create the market.
     create_market_receipt_tx = factory_contract.create2FixedProductMarketMaker(
-        from_private_key=from_private_key,
+        private_credentials=private_credentials,
         condition_id=condition_id,
         fee=fee,
         initial_funds_wei=initial_funds_wei,
@@ -544,12 +598,12 @@ def omen_create_market_tx(
 
 
 def omen_fund_market_tx(
+    private_credentials: PrivateCredentials,
     market: OmenAgentMarket,
     funds: Wei,
-    from_private_key: PrivateKey,
     auto_deposit: bool,
 ) -> None:
-    from_address = private_key_to_public_key(from_private_key)
+    from_address = private_credentials.public_key
     market_contract = market.get_contract()
     collateral_token_contract = OmenCollateralTokenContract()
 
@@ -562,15 +616,15 @@ def omen_fund_market_tx(
         )
         < funds
     ):
-        collateral_token_contract.deposit(funds, from_private_key)
+        collateral_token_contract.deposit(private_credentials, funds)
 
     collateral_token_contract.approve(
+        private_credentials=private_credentials,
         for_address=market_contract.address,
         amount_wei=funds,
-        from_private_key=from_private_key,
     )
 
-    market_contract.addFunding(funds, from_private_key)
+    market_contract.addFunding(private_credentials, funds)
 
 
 def build_parent_collection_id() -> HexStr:
@@ -578,8 +632,8 @@ def build_parent_collection_id() -> HexStr:
 
 
 def omen_redeem_full_position_tx(
+    private_credentials: PrivateCredentials,
     market: OmenAgentMarket,
-    from_private_key: PrivateKey,
     web3: Web3 | None = None,
 ) -> None:
     """
@@ -587,7 +641,7 @@ def omen_redeem_full_position_tx(
     to be redeemed before sending the transaction.
     """
 
-    from_address = private_key_to_public_key(from_private_key)
+    from_address = private_credentials.public_key
 
     market_contract: OmenFixedProductMarketMakerContract = market.get_contract()
     conditional_token_contract = OmenConditionalTokenContract()
@@ -617,7 +671,7 @@ def omen_redeem_full_position_tx(
         return
 
     conditional_token_contract.redeemPositions(
-        from_private_key=from_private_key,
+        private_credentials=private_credentials,
         collateral_token_address=market.collateral_token_contract_address_checksummed,
         condition_id=market.condition.id,
         parent_collection_id=parent_collection_id,
@@ -658,9 +712,9 @@ def get_conditional_tokens_balance_for_market(
 
 
 def omen_remove_fund_market_tx(
+    private_credentials: PrivateCredentials,
     market: OmenAgentMarket,
     shares: Wei | None,
-    from_private_key: PrivateKey,
     web3: Web3 | None = None,
 ) -> None:
     """
@@ -671,7 +725,7 @@ def omen_remove_fund_market_tx(
     After we remove funding, using the `mergePositions` we get `min(shares per index)` of wxDai back, but the remaining shares can be converted back only after the market is resolved.
     That can be done using the `redeem_from_all_user_positions` function below.
     """
-    from_address = private_key_to_public_key(from_private_key)
+    from_address = private_credentials.public_key
     market_contract = market.get_contract()
     original_balances = get_balances(from_address)
 
@@ -687,7 +741,7 @@ def omen_remove_fund_market_tx(
         shares = total_shares
 
     market_contract.removeFunding(
-        remove_funding=shares, from_private_key=from_private_key, web3=web3
+        private_credentials=private_credentials, remove_funding=shares, web3=web3
     )
 
     conditional_tokens = OmenConditionalTokenContract()
@@ -701,7 +755,7 @@ def omen_remove_fund_market_tx(
     amount_to_merge = min(amount_per_index_set.values())
 
     result = conditional_tokens.mergePositions(
-        from_private_key=from_private_key,
+        private_credentials=private_credentials,
         collateral_token_address=market.collateral_token_contract_address_checksummed,
         parent_collection_id=parent_collection_id,
         conditionId=market.condition.id,
@@ -718,13 +772,13 @@ def omen_remove_fund_market_tx(
 
 
 def redeem_from_all_user_positions(
-    from_private_key: PrivateKey,
+    private_credentials: PrivateCredentials,
     web3: Web3 | None = None,
 ) -> None:
     """
     Redeems from all user positions where the user didn't redeem yet.
     """
-    public_key = private_key_to_public_key(from_private_key)
+    public_key = private_credentials.public_key
 
     conditional_token_contract = OmenConditionalTokenContract()
     user_positions = OmenSubgraphHandler().get_user_positions(
@@ -748,7 +802,7 @@ def redeem_from_all_user_positions(
 
         original_balances = get_balances(public_key)
         conditional_token_contract.redeemPositions(
-            from_private_key=from_private_key,
+            private_credentials=private_credentials,
             collateral_token_address=user_position.position.collateral_token_contract_address_checksummed,
             condition_id=condition_id,
             parent_collection_id=build_parent_collection_id(),
@@ -760,3 +814,32 @@ def redeem_from_all_user_positions(
         logger.info(
             f"Redeemed {new_balances.wxdai - original_balances.wxdai} wxDai from position {user_position.id=}."
         )
+
+
+def get_binary_market_p_yes_history(market: OmenAgentMarket) -> list[Probability]:
+    history: list[Probability] = []
+    trades = sorted(
+        OmenSubgraphHandler().get_trades(  # We need to look at price both after buying or selling, so get trades, not bets.
+            market_id=market.market_maker_contract_address_checksummed,
+            end_time=market.close_time,  # Even after market is closed, there can be many `Sell` trades which will converge the probability to the true one.
+        ),
+        key=lambda x: x.creation_datetime,
+    )
+
+    for index, trade in enumerate(trades):
+        # We need to append the old probability to have also the initial state of the market (before any bet placement).
+        history.append(
+            trade.old_probability
+            if trade.outcomeIndex == market.yes_index
+            else Probability(1 - trade.old_probability)
+        )
+
+        # At the last trade, we also need to append the new probability, to have the market latest state.
+        if index == len(trades) - 1:
+            history.append(
+                trade.probability
+                if trade.outcomeIndex == market.yes_index
+                else Probability(1 - trade.probability)
+            )
+
+    return history