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

prediction_market_agent_tooling/markets/omen/omen_contracts.py

@@ -6,6 +6,7 @@ from enum import Enum
 
 from web3 import Web3
 
+from prediction_market_agent_tooling.config import PrivateCredentials
 from prediction_market_agent_tooling.gtypes import (
     ABI,
     ChecksumAddress,
@@ -13,7 +14,6 @@ from prediction_market_agent_tooling.gtypes import (
     HexBytes,
     HexStr,
     OmenOutcomeToken,
-    PrivateKey,
     TxParams,
     TxReceipt,
     Wei,
@@ -51,14 +51,14 @@ class OmenOracleContract(ContractOnGnosisChain):
 
     def resolve(
         self,
+        private_credentials: PrivateCredentials,
         question_id: HexBytes,
         template_id: int,
         question_raw: str,
         n_outcomes: int,
-        from_private_key: PrivateKey,
     ) -> TxReceipt:
         return self.send(
-            from_private_key=from_private_key,
+            private_credentials=private_credentials,
             function_name="resolve",
             function_params=dict(
                 questionId=question_id,
@@ -134,7 +134,7 @@ class OmenConditionalTokenContract(ContractOnGnosisChain):
 
     def mergePositions(
         self,
-        from_private_key: PrivateKey,
+        private_credentials: PrivateCredentials,
         collateral_token_address: ChecksumAddress,
         parent_collection_id: HexStr,
         conditionId: HexBytes,
@@ -143,7 +143,7 @@ class OmenConditionalTokenContract(ContractOnGnosisChain):
         web3: Web3 | None = None,
     ) -> TxReceipt:
         return self.send(
-            from_private_key=from_private_key,
+            private_credentials=private_credentials,
             function_name="mergePositions",
             function_params=[
                 collateral_token_address,
@@ -157,7 +157,7 @@ class OmenConditionalTokenContract(ContractOnGnosisChain):
 
     def redeemPositions(
         self,
-        from_private_key: PrivateKey,
+        private_credentials: PrivateCredentials,
         collateral_token_address: HexAddress,
         condition_id: HexBytes,
         parent_collection_id: HexStr,
@@ -165,7 +165,7 @@ class OmenConditionalTokenContract(ContractOnGnosisChain):
         web3: Web3 | None = None,
     ) -> TxReceipt:
         return self.send(
-            from_private_key=from_private_key,
+            private_credentials=private_credentials,
             function_name="redeemPositions",
             function_params=[
                 collateral_token_address,
@@ -210,13 +210,13 @@ class OmenConditionalTokenContract(ContractOnGnosisChain):
 
     def setApprovalForAll(
         self,
+        private_credentials: PrivateCredentials,
         for_address: ChecksumAddress,
         approve: bool,
-        from_private_key: PrivateKey,
         tx_params: t.Optional[TxParams] = None,
     ) -> TxReceipt:
         return self.send(
-            from_private_key=from_private_key,
+            private_credentials=private_credentials,
             function_name="setApprovalForAll",
             function_params=[
                 for_address,
@@ -227,14 +227,14 @@ class OmenConditionalTokenContract(ContractOnGnosisChain):
 
     def prepareCondition(
         self,
+        private_credentials: PrivateCredentials,
         oracle_address: ChecksumAddress,
         question_id: HexBytes,
         outcomes_slot_count: int,
-        from_private_key: PrivateKey,
         tx_params: t.Optional[TxParams] = None,
     ) -> TxReceipt:
         return self.send(
-            from_private_key=from_private_key,
+            private_credentials=private_credentials,
             function_name="prepareCondition",
             function_params=[
                 oracle_address,
@@ -261,16 +261,13 @@ class OmenFixedProductMarketMakerContract(ContractOnGnosisChain):
         return balance
 
     def calcBuyAmount(
-        self,
-        investment_amount: Wei,
-        outcome_index: int,
+        self, investment_amount: Wei, outcome_index: int, web3: Web3 | None = None
     ) -> OmenOutcomeToken:
         """
         Returns amount of shares we will get for the given outcome_index for the given investment amount.
         """
         calculated_shares: OmenOutcomeToken = self.call(
-            "calcBuyAmount",
-            [investment_amount, outcome_index],
+            "calcBuyAmount", [investment_amount, outcome_index], web3=web3
         )
         return calculated_shares
 
@@ -298,14 +295,15 @@ class OmenFixedProductMarketMakerContract(ContractOnGnosisChain):
 
     def buy(
         self,
+        private_credentials: PrivateCredentials,
         amount_wei: Wei,
         outcome_index: int,
         min_outcome_tokens_to_buy: OmenOutcomeToken,
-        from_private_key: PrivateKey,
         tx_params: t.Optional[TxParams] = None,
+        web3: Web3 | None = None,
     ) -> TxReceipt:
         return self.send(
-            from_private_key=from_private_key,
+            private_credentials=private_credentials,
             function_name="buy",
             function_params=[
                 amount_wei,
@@ -313,18 +311,19 @@ class OmenFixedProductMarketMakerContract(ContractOnGnosisChain):
                 min_outcome_tokens_to_buy,
             ],
             tx_params=tx_params,
+            web3=web3,
         )
 
     def sell(
         self,
+        private_credentials: PrivateCredentials,
         amount_wei: Wei,
         outcome_index: int,
         max_outcome_tokens_to_sell: OmenOutcomeToken,
-        from_private_key: PrivateKey,
         tx_params: t.Optional[TxParams] = None,
     ) -> TxReceipt:
         return self.send(
-            from_private_key=from_private_key,
+            private_credentials=private_credentials,
             function_name="sell",
             function_params=[
                 amount_wei,
@@ -336,8 +335,8 @@ class OmenFixedProductMarketMakerContract(ContractOnGnosisChain):
 
     def addFunding(
         self,
+        private_credentials: PrivateCredentials,
         add_funding: Wei,
-        from_private_key: PrivateKey,
         tx_params: t.Optional[TxParams] = None,
     ) -> TxReceipt:
         """
@@ -346,7 +345,7 @@ class OmenFixedProductMarketMakerContract(ContractOnGnosisChain):
         # `addFunding` with `distribution_hint` can be used only during the market creation, so forcing empty here.
         distribution_hint: list[int] = []
         return self.send(
-            from_private_key=from_private_key,
+            private_credentials=private_credentials,
             function_name="addFunding",
             function_params=[add_funding, distribution_hint],
             tx_params=tx_params,
@@ -354,8 +353,8 @@ class OmenFixedProductMarketMakerContract(ContractOnGnosisChain):
 
     def removeFunding(
         self,
+        private_credentials: PrivateCredentials,
         remove_funding: Wei,
-        from_private_key: PrivateKey,
         tx_params: t.Optional[TxParams] = None,
         web3: Web3 | None = None,
     ) -> TxReceipt:
@@ -363,7 +362,7 @@ class OmenFixedProductMarketMakerContract(ContractOnGnosisChain):
         Remove funding is done in shares.
         """
         return self.send(
-            from_private_key=from_private_key,
+            private_credentials=private_credentials,
             function_name="removeFunding",
             function_params=[remove_funding],
             tx_params=tx_params,
@@ -408,9 +407,9 @@ class OmenFixedProductMarketMakerFactoryContract(ContractOnGnosisChain):
 
     def create2FixedProductMarketMaker(
         self,
+        private_credentials: PrivateCredentials,
         condition_id: HexBytes,
         initial_funds_wei: Wei,
-        from_private_key: PrivateKey,
         fee: float = OMEN_DEFAULT_MARKET_FEE,
         tx_params: t.Optional[TxParams] = None,
     ) -> TxReceipt:
@@ -418,7 +417,7 @@ class OmenFixedProductMarketMakerFactoryContract(ContractOnGnosisChain):
             xdai_type(fee)
         )  # We need to convert this to the wei units, but in reality it's % fee as stated in the `OMEN_DEFAULT_MARKET_FEE` variable.
         return self.send(
-            from_private_key=from_private_key,
+            private_credentials=private_credentials,
             function_name="create2FixedProductMarketMaker",
             function_params=dict(
                 saltNonce=random.randint(
@@ -490,13 +489,13 @@ class OmenRealitioContract(ContractOnGnosisChain):
 
     def askQuestion(
         self,
+        private_credentials: PrivateCredentials,
         question: str,
         category: str,
         outcomes: list[str],
         language: str,
         arbitrator: Arbitrator,
         opening: datetime,
-        from_private_key: PrivateKey,
         nonce: int | None = None,
         tx_params: t.Optional[TxParams] = None,
     ) -> HexBytes:
@@ -516,7 +515,7 @@ class OmenRealitioContract(ContractOnGnosisChain):
             ]
         )
         receipt_tx = self.send(
-            from_private_key=from_private_key,
+            private_credentials=private_credentials,
             function_name="askQuestion",
             function_params=dict(
                 template_id=template_id,
@@ -537,11 +536,11 @@ class OmenRealitioContract(ContractOnGnosisChain):
 
     def submitAnswer(
         self,
+        private_credentials: PrivateCredentials,
         question_id: HexBytes,
         answer: str,
         outcomes: list[str],
         bond: Wei,
-        from_private_key: PrivateKey,
         max_previous: Wei | None = None,
     ) -> TxReceipt:
         if max_previous is None:
@@ -554,7 +553,7 @@ class OmenRealitioContract(ContractOnGnosisChain):
         outcomes = [o.lower() for o in outcomes]
 
         return self.send_with_value(
-            from_private_key=from_private_key,
+            private_credentials=private_credentials,
             function_name="submitAnswer",
             function_params=dict(
                 question_id=question_id,
@@ -568,15 +567,16 @@ class OmenRealitioContract(ContractOnGnosisChain):
 
     def claimWinnings(
         self,
+        private_credentials: PrivateCredentials,
         question_id: HexBytes,
         history_hashes: list[HexBytes],
         addresses: list[ChecksumAddress],
         bonds: list[Wei],
         answers: list[HexBytes],
-        from_private_key: PrivateKey,
         tx_params: t.Optional[TxParams] = None,
     ) -> TxReceipt:
         return self.send(
+            private_credentials=private_credentials,
             function_name="claimWinnings",
             function_params=dict(
                 question_id=question_id,
@@ -585,7 +585,6 @@ class OmenRealitioContract(ContractOnGnosisChain):
                 bonds=bonds,
                 answers=answers,
             ),
-            from_private_key=from_private_key,
             tx_params=tx_params,
         )
 
@@ -593,8 +592,11 @@ class OmenRealitioContract(ContractOnGnosisChain):
         balance = wei_type(self.call("balanceOf", [from_address]))
         return balance
 
-    def withdraw(self, from_private_key: PrivateKey) -> TxReceipt:
+    def withdraw(
+        self,
+        private_credentials: PrivateCredentials,
+    ) -> TxReceipt:
         return self.send(
+            private_credentials=private_credentials,
             function_name="withdraw",
-            from_private_key=from_private_key,
         )

prediction_market_agent_tooling/markets/omen/omen_replicate.py

@@ -2,12 +2,8 @@ from datetime import datetime, timedelta
 
 from loguru import logger
 
-from prediction_market_agent_tooling.gtypes import (
-    ChecksumAddress,
-    PrivateKey,
-    wei_type,
-    xDai,
-)
+from prediction_market_agent_tooling.config import PrivateCredentials
+from prediction_market_agent_tooling.gtypes import ChecksumAddress, wei_type, xDai
 from prediction_market_agent_tooling.markets.agent_market import FilterBy, SortBy
 from prediction_market_agent_tooling.markets.categorize import infer_category
 from prediction_market_agent_tooling.markets.markets import (
@@ -29,7 +25,6 @@ from prediction_market_agent_tooling.markets.omen.omen_subgraph_handler import (
 )
 from prediction_market_agent_tooling.tools.is_predictable import is_predictable_binary
 from prediction_market_agent_tooling.tools.utils import utcnow
-from prediction_market_agent_tooling.tools.web3_utils import private_key_to_public_key
 
 # According to Omen's recommendation, closing time of the market should be at least 6 days after the outcome is known.
 # That is because at the closing time, the question will open on Realitio, and we don't want it to be resolved as unknown/invalid.
@@ -38,14 +33,14 @@ EXTEND_CLOSING_TIME_DELTA = timedelta(days=6)
 
 
 def omen_replicate_from_tx(
+    private_credentials: PrivateCredentials,
     market_type: MarketType,
     n_to_replicate: int,
     initial_funds: xDai,
-    from_private_key: PrivateKey,
     close_time_before: datetime | None = None,
     auto_deposit: bool = False,
 ) -> list[ChecksumAddress]:
-    from_address = private_key_to_public_key(from_private_key)
+    from_address = private_credentials.public_key
     already_created_markets = OmenSubgraphHandler().get_omen_binary_markets(
         limit=None,
         creator=from_address,
@@ -120,13 +115,13 @@ def omen_replicate_from_tx(
             continue
 
         market_address = omen_create_market_tx(
+            private_credentials=private_credentials,
             initial_funds=initial_funds,
             fee=OMEN_DEFAULT_MARKET_FEE,
             question=market.question,
             closing_time=safe_closing_time,
             category=category,
             language="en",
-            from_private_key=from_private_key,
             outcomes=[OMEN_TRUE_OUTCOME, OMEN_FALSE_OUTCOME],
             auto_deposit=auto_deposit,
         )
@@ -145,10 +140,10 @@ def omen_replicate_from_tx(
 
 
 def omen_unfund_replicated_known_markets_tx(
-    from_private_key: PrivateKey,
+    private_credentials: PrivateCredentials,
     saturation_above_threshold: float | None = None,
 ) -> None:
-    from_address = private_key_to_public_key(from_private_key)
+    from_address = private_credentials.public_key
 
     now = utcnow()
     # We want to unfund markets ~1 day before the resolution should be known.
@@ -171,19 +166,19 @@ def omen_unfund_replicated_known_markets_tx(
             saturation_above_threshold is not None
             and not market.is_resolved
             and not (
-                market.p_yes > saturation_above_threshold
-                or market.p_no > saturation_above_threshold
+                market.current_p_yes > saturation_above_threshold
+                or market.current_p_no > saturation_above_threshold
             )
         ):
             logger.info(
-                f"[{idx+1}/{len(markets)}] Skipping unfunding of `{market.liquidityParameter=} {market.question=}  {market.url=}`, because it's not saturated yet, `{market.p_yes=}`."
+                f"[{idx+1}/{len(markets)}] Skipping unfunding of `{market.liquidityParameter=} {market.question=}  {market.url=}`, because it's not saturated yet, `{market.current_p_yes=}`."
             )
             continue
         logger.info(
             f"[{idx+1}/{len(markets)}] Unfunding market `{market.liquidityParameter=} {market.question=} {market.url=}`."
         )
         omen_remove_fund_market_tx(
+            private_credentials=private_credentials,
             market=OmenAgentMarket.from_data_model(market),
             shares=None,
-            from_private_key=from_private_key,
         )

prediction_market_agent_tooling/markets/omen/omen_resolve_replicated.py

@@ -4,11 +4,11 @@ from loguru import logger
 from pydantic import BaseModel
 from web3 import Web3
 
+from prediction_market_agent_tooling.config import PrivateCredentials
 from prediction_market_agent_tooling.gtypes import (
     ChecksumAddress,
     HexAddress,
     HexBytes,
-    PrivateKey,
     Wei,
     xDai,
 )
@@ -36,11 +36,7 @@ from prediction_market_agent_tooling.markets.polymarket.utils import (
 )
 from prediction_market_agent_tooling.tools.balances import get_balances
 from prediction_market_agent_tooling.tools.utils import utcnow
-from prediction_market_agent_tooling.tools.web3_utils import (
-    ZERO_BYTES,
-    private_key_to_public_key,
-    xdai_to_wei,
-)
+from prediction_market_agent_tooling.tools.web3_utils import ZERO_BYTES, xdai_to_wei
 
 
 class FinalizeAndResolveResult(BaseModel):
@@ -50,9 +46,9 @@ class FinalizeAndResolveResult(BaseModel):
 
 
 def omen_finalize_and_resolve_and_claim_back_all_markets_based_on_others_tx(
-    from_private_key: PrivateKey,
+    private_credentials: PrivateCredentials,
 ) -> FinalizeAndResolveResult:
-    public_key = private_key_to_public_key(from_private_key)
+    public_key = private_credentials.public_key
     balances_start = get_balances(public_key)
     logger.info(f"{balances_start=}")
 
@@ -68,7 +64,8 @@ def omen_finalize_and_resolve_and_claim_back_all_markets_based_on_others_tx(
     )
     # Finalize them (set answer on Realitio).
     finalized_markets = finalize_markets(
-        created_opened_markets, from_private_key=from_private_key
+        private_credentials,
+        created_opened_markets,
     )
     balances_after_finalization = get_balances(public_key)
     logger.info(f"{balances_after_finalization=}")
@@ -82,7 +79,8 @@ def omen_finalize_and_resolve_and_claim_back_all_markets_based_on_others_tx(
     )
     # Resolve them (resolve them on Oracle).
     resolved_markets = resolve_markets(
-        created_finalized_markets, from_private_key=from_private_key
+        private_credentials,
+        created_finalized_markets,
     )
     balances_after_resolution = get_balances(public_key)
     logger.info(f"{balances_after_resolution=}")
@@ -96,7 +94,9 @@ def omen_finalize_and_resolve_and_claim_back_all_markets_based_on_others_tx(
         current_answer_before=before - timedelta(hours=24),
     )
     claimed_question_ids = claim_bonds_on_realitio_quetions(
-        created_not_claimed_questions, from_private_key, auto_withdraw=True
+        private_credentials,
+        created_not_claimed_questions,
+        auto_withdraw=True,
     )
     balances_after_claiming = get_balances(public_key)
     logger.info(f"{balances_after_claiming=}")
@@ -109,7 +109,9 @@ def omen_finalize_and_resolve_and_claim_back_all_markets_based_on_others_tx(
 
 
 def claim_bonds_on_realitio_quetions(
-    questions: list[RealityQuestion], from_private_key: PrivateKey, auto_withdraw: bool
+    private_credentials: PrivateCredentials,
+    questions: list[RealityQuestion],
+    auto_withdraw: bool,
 ) -> list[HexBytes]:
     claimed_questions: list[HexBytes] = []
 
@@ -118,7 +120,7 @@ def claim_bonds_on_realitio_quetions(
             f"[{idx+1} / {len(questions)}] Claiming bond for {question.questionId=} {question.url=}"
         )
         claim_bonds_on_realitio_question(
-            question, from_private_key, auto_withdraw=auto_withdraw
+            private_credentials, question, auto_withdraw=auto_withdraw
         )
         claimed_questions.append(question.questionId)
 
@@ -126,11 +128,11 @@ def claim_bonds_on_realitio_quetions(
 
 
 def claim_bonds_on_realitio_question(
+    private_credentials: PrivateCredentials,
     question: RealityQuestion,
-    from_private_key: PrivateKey,
     auto_withdraw: bool,
 ) -> None:
-    public_key = private_key_to_public_key(from_private_key)
+    public_key = private_credentials.public_key
     realitio_contract = OmenRealitioContract()
 
     # Get all answers for the question.
@@ -175,23 +177,24 @@ def claim_bonds_on_realitio_question(
         answers.append(answer.answer)
 
     realitio_contract.claimWinnings(
+        private_credentials=private_credentials,
         question_id=question.questionId,
         history_hashes=history_hashes,
         addresses=addresses,
         bonds=bonds,
         answers=answers,
-        from_private_key=from_private_key,
     )
 
     current_balance = realitio_contract.balanceOf(public_key)
     # Keeping balance on Realitio is not useful, so it's recommended to just withdraw it.
     if current_balance > 0 and auto_withdraw:
         logger.info(f"Withdrawing remaining balance {current_balance=}")
-        realitio_contract.withdraw(from_private_key)
+        realitio_contract.withdraw(private_credentials)
 
 
 def finalize_markets(
-    markets: list[OmenMarket], from_private_key: PrivateKey
+    private_credentials: PrivateCredentials,
+    markets: list[OmenMarket],
 ) -> list[HexAddress]:
     finalized_markets: list[HexAddress] = []
 
@@ -207,7 +210,10 @@ def finalize_markets(
         elif resolution in (Resolution.YES, Resolution.NO):
             logger.info(f"Found resolution {resolution.value=} for {market.url=}")
             omen_submit_answer_market_tx(
-                market, resolution, OMEN_DEFAULT_REALITIO_BOND_VALUE, from_private_key
+                private_credentials,
+                market,
+                resolution,
+                OMEN_DEFAULT_REALITIO_BOND_VALUE,
             )
             finalized_markets.append(market.id)
             logger.info(f"Finalized {market.url=}")
@@ -219,7 +225,8 @@ def finalize_markets(
 
 
 def resolve_markets(
-    markets: list[OmenMarket], from_private_key: PrivateKey
+    private_credentials: PrivateCredentials,
+    markets: list[OmenMarket],
 ) -> list[HexAddress]:
     resolved_markets: list[HexAddress] = []
 
@@ -227,17 +234,17 @@ def resolve_markets(
         logger.info(
             f"[{idx+1} / {len(markets)}] Resolving {market.url=} {market.question_title=}"
         )
-        omen_resolve_market_tx(market, from_private_key)
+        omen_resolve_market_tx(private_credentials, market)
         resolved_markets.append(market.id)
 
     return resolved_markets
 
 
 def omen_submit_answer_market_tx(
+    private_credentials: PrivateCredentials,
     market: OmenMarket,
     resolution: Resolution,
     bond: xDai,
-    from_private_key: PrivateKey,
 ) -> None:
     """
     After the answer is submitted, there is 24h waiting period where the answer can be challenged by others.
@@ -245,28 +252,28 @@ def omen_submit_answer_market_tx(
     """
     realitio_contract = OmenRealitioContract()
     realitio_contract.submitAnswer(
+        private_credentials=private_credentials,
         question_id=market.question.id,
         answer=resolution.value,
         outcomes=market.question.outcomes,
         bond=xdai_to_wei(bond),
-        from_private_key=from_private_key,
     )
 
 
 def omen_resolve_market_tx(
+    private_credentials: PrivateCredentials,
     market: OmenMarket,
-    from_private_key: PrivateKey,
 ) -> None:
     """
     Market can be resolved 24h after last answer was submitted via `omen_submit_answer_market_tx`.
     """
     oracle_contract = OmenOracleContract()
     oracle_contract.resolve(
+        private_credentials=private_credentials,
         question_id=market.question.id,
         template_id=market.question.templateId,
         question_raw=market.question.question_raw,
         n_outcomes=market.question.n_outcomes,
-        from_private_key=from_private_key,
     )