prediction-market-agent-tooling 0.43.2__py3-none-any.whl → 0.44.0__py3-none-any.whl

prediction_market_agent_tooling/markets/omen/data_models.py

@@ -32,6 +32,7 @@ OMEN_TRUE_OUTCOME = "Yes"
 OMEN_FALSE_OUTCOME = "No"
 INVALID_ANSWER = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
 OMEN_BASE_URL = "https://aiomen.eth.limo"
+PRESAGIO_BASE_URL = "https://presagio.pages.dev"
 
 
 def get_boolean_outcome(outcome_str: str) -> bool:
@@ -325,7 +326,7 @@ class OmenMarket(BaseModel):
 
     @property
     def url(self) -> str:
-        return f"{OMEN_BASE_URL}/#/{self.id}"
+        return f"{PRESAGIO_BASE_URL}/markets?id={self.id}"
 
 
 class OmenBetCreator(BaseModel):

prediction_market_agent_tooling/markets/omen/omen.py

@@ -2,6 +2,7 @@ import sys
 import typing as t
 from datetime import datetime
 
+import tenacity
 from web3 import Web3
 from web3.constants import HASH_ZERO
 
@@ -32,9 +33,9 @@ from prediction_market_agent_tooling.markets.data_models import (
     TokenAmount,
 )
 from prediction_market_agent_tooling.markets.omen.data_models import (
-    OMEN_BASE_URL,
     OMEN_FALSE_OUTCOME,
     OMEN_TRUE_OUTCOME,
+    PRESAGIO_BASE_URL,
     Condition,
     OmenBet,
     OmenMarket,
@@ -43,17 +44,24 @@ from prediction_market_agent_tooling.markets.omen.data_models import (
 from prediction_market_agent_tooling.markets.omen.omen_contracts import (
     OMEN_DEFAULT_MARKET_FEE,
     Arbitrator,
-    OmenCollateralTokenContract,
     OmenConditionalTokenContract,
     OmenFixedProductMarketMakerContract,
     OmenFixedProductMarketMakerFactoryContract,
     OmenOracleContract,
     OmenRealitioContract,
+    WrappedxDaiContract,
 )
 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 (
+    ContractDepositableWrapperERC20BaseClass,
+    ContractERC4626BaseClass,
+    auto_deposit_collateral_token,
+    init_collateral_token_contract,
+    to_gnosis_chain_contract,
+)
 from prediction_market_agent_tooling.tools.hexbytes_custom import HexBytes
 from prediction_market_agent_tooling.tools.utils import (
     calculate_sell_amount_in_collateral,
@@ -75,7 +83,7 @@ class OmenAgentMarket(AgentMarket):
     """
 
     currency: t.ClassVar[Currency] = Currency.xDai
-    base_url: t.ClassVar[str] = OMEN_BASE_URL
+    base_url: t.ClassVar[str] = PRESAGIO_BASE_URL
     creator: HexAddress
 
     collateral_token_contract_address_checksummed: ChecksumAddress
@@ -134,11 +142,12 @@ class OmenAgentMarket(AgentMarket):
     def get_liquidity(self) -> TokenAmount:
         return TokenAmount(
             amount=self.get_liquidity_in_xdai(),
-            currency=Currency.xDai,
+            currency=self.currency,
         )
 
-    def get_tiny_bet_amount(self) -> BetAmount:
-        return BetAmount(amount=0.00001, currency=self.currency)
+    @classmethod
+    def get_tiny_bet_amount(cls) -> BetAmount:
+        return BetAmount(amount=0.00001, currency=cls.currency)
 
     def place_bet(
         self,
@@ -381,7 +390,7 @@ class OmenAgentMarket(AgentMarket):
         )
         return TokenAmount(
             amount=wei_to_xdai(balances[index_set]),
-            currency=Currency.xDai,
+            currency=self.currency,
         )
 
     @classmethod
@@ -437,7 +446,7 @@ class OmenAgentMarket(AgentMarket):
 
                 amounts[outecome_str] = TokenAmount(
                     amount=wei_to_xdai(omen_position.totalBalance),
-                    currency=Currency.xDai,
+                    currency=cls.currency,
                 )
 
             positions.append(Position(market_id=market.id, amounts=amounts))
@@ -503,7 +512,7 @@ class OmenAgentMarket(AgentMarket):
                     no_price = check_not_none(market.get_last_trade_no_outcome_price())
                     total_position_value += no_tokens * no_price
 
-        return BetAmount(amount=total_position_value, currency=Currency.xDai)
+        return BetAmount(amount=total_position_value, currency=cls.currency)
 
     @classmethod
     def get_user_url(cls, keys: APIKeys) -> str:
@@ -523,6 +532,11 @@ def pick_binary_market(
     )[0]
 
 
+@tenacity.retry(
+    stop=tenacity.stop_after_attempt(3),
+    wait=tenacity.wait_fixed(1),
+    after=lambda x: logger.debug(f"omen_buy_outcome_tx failed, {x.attempt_number=}."),
+)
 def omen_buy_outcome_tx(
     api_keys: APIKeys,
     amount: xDai,
@@ -535,11 +549,9 @@ def omen_buy_outcome_tx(
     Bets the given amount of xDai for the given outcome in the given market.
     """
     amount_wei = xdai_to_wei(amount)
-    from_address_checksummed = api_keys.bet_from_address
 
     market_contract: OmenFixedProductMarketMakerContract = market.get_contract()
-
-    collateral_token_contract = OmenCollateralTokenContract()
+    collateral_token_contract = market_contract.get_collateral_token_contract()
 
     # Get the index of the outcome we want to buy.
     outcome_index: int = market.get_outcome_index(outcome)
@@ -557,16 +569,12 @@ def omen_buy_outcome_tx(
         amount_wei=amount_wei,
         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, web3=web3
-    )
-    if auto_deposit and collateral_token_balance < amount_wei:
-        deposit_amount_wei = Wei(amount_wei - collateral_token_balance)
-        collateral_token_contract.deposit(
-            api_keys=api_keys, amount_wei=deposit_amount_wei, web3=web3
+
+    if auto_deposit:
+        auto_deposit_collateral_token(
+            collateral_token_contract, amount_wei, api_keys, web3
         )
+
     # Buy shares using the deposited xDai in the collateral token.
     market_contract.buy(
         api_keys=api_keys,
@@ -614,7 +622,7 @@ def omen_sell_outcome_tx(
 
     market_contract: OmenFixedProductMarketMakerContract = market.get_contract()
     conditional_token_contract = OmenConditionalTokenContract()
-    collateral_token = OmenCollateralTokenContract()
+    collateral_token_contract = market_contract.get_collateral_token_contract()
 
     # Verify, that markets uses conditional tokens that we expect.
     if (
@@ -650,9 +658,20 @@ def omen_sell_outcome_tx(
         max_outcome_tokens_to_sell,
         web3=web3,
     )
-    if auto_withdraw:
-        # Optionally, withdraw from the collateral token back to the `from_address` wallet.
-        collateral_token.withdraw(api_keys=api_keys, amount_wei=amount_wei, web3=web3)
+    if auto_withdraw and (
+        isinstance(collateral_token_contract, ContractERC4626BaseClass)
+        or isinstance(
+            collateral_token_contract, ContractDepositableWrapperERC20BaseClass
+        )
+    ):
+        collateral_token_contract.withdraw(
+            api_keys,
+            remove_fraction(
+                amount_wei,
+                0.001,  # Allow 0.1% slippage.
+            ),
+            web3,
+        )
 
 
 def binary_omen_sell_outcome_tx(
@@ -683,17 +702,22 @@ def omen_create_market_tx(
     outcomes: list[str],
     auto_deposit: bool,
     fee: float = OMEN_DEFAULT_MARKET_FEE,
+    collateral_token_address: ChecksumAddress = WrappedxDaiContract().address,
     web3: Web3 | None = None,
 ) -> ChecksumAddress:
     """
     Based on omen-exchange TypeScript code: https://github.com/protofire/omen-exchange/blob/b0b9a3e71b415d6becf21fe428e1c4fc0dad2e80/app/src/services/cpk/cpk.ts#L308
     """
-    from_address = api_keys.bet_from_address
+    web3 = (
+        web3 or OmenFixedProductMarketMakerFactoryContract.get_web3()
+    )  # Default to Gnosis web3.
     initial_funds_wei = xdai_to_wei(initial_funds)
 
     realitio_contract = OmenRealitioContract()
     conditional_token_contract = OmenConditionalTokenContract()
-    collateral_token_contract = OmenCollateralTokenContract()
+    collateral_token_contract = to_gnosis_chain_contract(
+        init_collateral_token_contract(collateral_token_address, web3)
+    )
     factory_contract = OmenFixedProductMarketMakerFactoryContract()
     oracle_contract = OmenOracleContract()
 
@@ -709,25 +733,13 @@ def omen_create_market_tx(
             "The oracle's conditional tokens address is not the same as we are using."
         )
 
-    # Approve the market maker to withdraw our collateral token.
-    collateral_token_contract.approve(
-        api_keys=api_keys,
-        for_address=factory_contract.address,
-        amount_wei=initial_funds_wei,
-        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, web3=web3
-    )
-    if (
-        auto_deposit
-        and initial_funds_wei > 0
-        and collateral_token_balance < initial_funds_wei
-    ):
-        collateral_token_contract.deposit(api_keys, initial_funds_wei, web3=web3)
+    if auto_deposit:
+        auto_deposit_collateral_token(
+            collateral_token_contract=collateral_token_contract,
+            api_keys=api_keys,
+            amount_wei=initial_funds_wei,
+            web3=web3,
+        )
 
     # Create the question on Realitio.
     question_id = realitio_contract.askQuestion(
@@ -757,12 +769,25 @@ def omen_create_market_tx(
             web3=web3,
         )
 
+    initial_funds_in_shares = collateral_token_contract.get_in_shares(
+        amount=initial_funds_wei, web3=web3
+    )
+
+    # Approve the market maker to withdraw our collateral token.
+    collateral_token_contract.approve(
+        api_keys=api_keys,
+        for_address=factory_contract.address,
+        amount_wei=initial_funds_in_shares,
+        web3=web3,
+    )
+
     # Create the market.
     create_market_receipt_tx = factory_contract.create2FixedProductMarketMaker(
         api_keys=api_keys,
         condition_id=condition_id,
         fee=fee,
-        initial_funds_wei=initial_funds_wei,
+        initial_funds_wei=initial_funds_in_shares,
+        collateral_token_address=collateral_token_contract.address,
         web3=web3,
     )
 
@@ -784,18 +809,11 @@ def omen_fund_market_tx(
     auto_deposit: bool,
     web3: Web3 | None = None,
 ) -> None:
-    from_address = api_keys.bet_from_address
     market_contract = market.get_contract()
-    collateral_token_contract = OmenCollateralTokenContract()
+    collateral_token_contract = market_contract.get_collateral_token_contract()
 
-    # Deposit xDai to the collateral token,
-    # this can be skipped, if we know we already have enough collateral tokens.
-    if (
-        auto_deposit
-        and collateral_token_contract.balanceOf(for_address=from_address, web3=web3)
-        < funds
-    ):
-        collateral_token_contract.deposit(api_keys, funds, web3=web3)
+    if auto_deposit:
+        auto_deposit_collateral_token(collateral_token_contract, funds, api_keys, web3)
 
     collateral_token_contract.approve(
         api_keys=api_keys,
@@ -907,7 +925,8 @@ def omen_remove_fund_market_tx(
     """
     from_address = api_keys.bet_from_address
     market_contract = market.get_contract()
-    original_balances = get_balances(from_address, web3=web3)
+    market_collateral_token_contract = market_contract.get_collateral_token_contract()
+    original_balance = market_collateral_token_contract.balanceOf(from_address)
 
     total_shares = market_contract.balanceOf(from_address, web3=web3)
     if total_shares == 0:
@@ -942,11 +961,11 @@ def omen_remove_fund_market_tx(
         web3=web3,
     )
 
-    new_balances = get_balances(from_address, web3)
+    new_balance = market_collateral_token_contract.balanceOf(from_address)
 
     logger.debug(f"Result from merge positions {result}")
     logger.info(
-        f"Withdrawn {new_balances.wxdai - original_balances.wxdai} wxDai from liquidity at {market.url=}."
+        f"Withdrawn {new_balance - original_balance} {market_collateral_token_contract.symbol_cached()} from liquidity at {market.url=}."
     )
 
 
@@ -1052,8 +1071,8 @@ def withdraw_wxdai_to_xdai_to_keep_balance(
             f"Current wxDai balance {current_balances.wxdai} is less than the required minimum wxDai to withdraw {need_to_withdraw}."
         )
 
-    collateral_token_contract = OmenCollateralTokenContract()
-    collateral_token_contract.withdraw(
+    wxdai_contract = WrappedxDaiContract()
+    wxdai_contract.withdraw(
         api_keys=api_keys, amount_wei=xdai_to_wei(need_to_withdraw), web3=web3
     )
     logger.info(

prediction_market_agent_tooling/markets/omen/omen_contracts.py

@@ -23,9 +23,13 @@ from prediction_market_agent_tooling.gtypes import (
     xdai_type,
 )
 from prediction_market_agent_tooling.tools.contract import (
+    ContractDepositableWrapperERC20OnGnosisChain,
     ContractERC20OnGnosisChain,
+    ContractERC4626OnGnosisChain,
     ContractOnGnosisChain,
     abi_field_validator,
+    init_collateral_token_contract,
+    to_gnosis_chain_contract,
 )
 from prediction_market_agent_tooling.tools.web3_utils import (
     ZERO_BYTES,
@@ -291,9 +295,13 @@ class OmenFixedProductMarketMakerContract(ContractOnGnosisChain):
         )
         return calculated_shares
 
-    def conditionalTokens(self, web3: Web3 | None = None) -> HexAddress:
+    def conditionalTokens(self, web3: Web3 | None = None) -> ChecksumAddress:
         address: HexAddress = self.call("conditionalTokens", web3=web3)
-        return address
+        return Web3.to_checksum_address(address)
+
+    def collateralToken(self, web3: Web3 | None = None) -> ChecksumAddress:
+        address: HexAddress = self.call("collateralToken", web3=web3)
+        return Web3.to_checksum_address(address)
 
     def buy(
         self,
@@ -380,21 +388,26 @@ class OmenFixedProductMarketMakerContract(ContractOnGnosisChain):
         total_supply: Wei = self.call("totalSupply", web3=web3)
         return total_supply
 
-
-class WrappedxDaiContract(ContractERC20OnGnosisChain):
-    # File content taken from https://gnosisscan.io/address/0xe91d153e0b41518a2ce8dd3d7944fa863463a97d#code.
-    abi: ABI = abi_field_validator(
-        os.path.join(
-            os.path.dirname(os.path.realpath(__file__)), "../../abis/wxdai.abi.json"
+    def get_collateral_token_contract(
+        self, web3: Web3 | None = None
+    ) -> ContractERC20OnGnosisChain:
+        web3 = web3 or self.get_web3()
+        return to_gnosis_chain_contract(
+            init_collateral_token_contract(self.collateralToken(web3=web3), web3)
         )
-    )
+
+
+class WrappedxDaiContract(ContractDepositableWrapperERC20OnGnosisChain):
     address: ChecksumAddress = Web3.to_checksum_address(
         "0xe91d153e0b41518a2ce8dd3d7944fa863463a97d"
     )
 
 
-# Collateral token used on Omen is wrapped xDai.
-OmenCollateralTokenContract = WrappedxDaiContract
+class sDaiContract(ContractERC4626OnGnosisChain):
+    address: ChecksumAddress = Web3.to_checksum_address(
+        "0xaf204776c7245bF4147c2612BF6e5972Ee483701"
+    )
+
 
 OMEN_DEFAULT_MARKET_FEE = 0.02  # 2% fee from the buying shares amount.
 
@@ -416,6 +429,7 @@ class OmenFixedProductMarketMakerFactoryContract(ContractOnGnosisChain):
         api_keys: APIKeys,
         condition_id: HexBytes,
         initial_funds_wei: Wei,
+        collateral_token_address: ChecksumAddress,
         fee: float = OMEN_DEFAULT_MARKET_FEE,
         tx_params: t.Optional[TxParams] = None,
         web3: Web3 | None = None,
@@ -431,7 +445,7 @@ class OmenFixedProductMarketMakerFactoryContract(ContractOnGnosisChain):
                     0, 1000000
                 ),  # See https://github.com/protofire/omen-exchange/blob/923756c3a9ac370f8e89af8193393a53531e2c0f/app/src/services/cpk/fns.ts#L942.
                 conditionalTokens=OmenConditionalTokenContract().address,
-                collateralToken=OmenCollateralTokenContract().address,
+                collateralToken=collateral_token_address,
                 conditionIds=[condition_id],
                 fee=fee_wei,
                 initialFunds=initial_funds_wei,
@@ -678,3 +692,14 @@ class OmenThumbnailMapping(ContractOnGnosisChain):
             function_params=[market_address],
             web3=web3,
         )
+
+
+class CollateralTokenChoice(str, Enum):
+    wxdai = "wxdai"
+    sdai = "sdai"
+
+
+COLLATERAL_TOKEN_CHOICE_TO_ADDRESS = {
+    CollateralTokenChoice.wxdai: WrappedxDaiContract().address,
+    CollateralTokenChoice.sdai: sDaiContract().address,
+}

prediction_market_agent_tooling/markets/omen/omen_resolving.py

@@ -40,6 +40,7 @@ def claim_bonds_on_realitio_questions(
     questions: list[RealityQuestion],
     auto_withdraw: bool,
     web3: Web3 | None = None,
+    silent_errors: bool = False,
 ) -> list[HexBytes]:
     claimed_questions: list[HexBytes] = []
 
@@ -47,10 +48,19 @@ def claim_bonds_on_realitio_questions(
         logger.info(
             f"[{idx+1} / {len(questions)}] Claiming bond for {question.questionId=} {question.url=}"
         )
-        claim_bonds_on_realitio_question(
-            api_keys, question, auto_withdraw=auto_withdraw, web3=web3
-        )
-        claimed_questions.append(question.questionId)
+        try:
+            claim_bonds_on_realitio_question(
+                api_keys, question, auto_withdraw=auto_withdraw, web3=web3
+            )
+            claimed_questions.append(question.questionId)
+        except Exception as e:
+            # TODO: This shouldn't be required once `claim_bonds_on_realitio_question` below is fixed.
+            if silent_errors:
+                logger.warning(
+                    f"Error while claiming bond for {question.questionId=} {question.url=}: {e}"
+                )
+            else:
+                raise
 
     return claimed_questions
 
@@ -140,7 +150,7 @@ def finalize_markets(
         )
 
         if resolution is None:
-            logger.error(f"No resolution provided for {market.url=}")
+            logger.warning(f"No resolution provided for {market.url=}")
 
         elif resolution in (Resolution.YES, Resolution.NO):
             logger.info(f"Found resolution {resolution.value=} for {market.url=}")

prediction_market_agent_tooling/markets/omen/omen_subgraph_handler.py

@@ -25,6 +25,8 @@ from prediction_market_agent_tooling.markets.omen.data_models import (
 )
 from prediction_market_agent_tooling.markets.omen.omen_contracts import (
     OmenThumbnailMapping,
+    WrappedxDaiContract,
+    sDaiContract,
 )
 from prediction_market_agent_tooling.tools.singleton import SingletonMeta
 from prediction_market_agent_tooling.tools.utils import to_int_timestamp, utcnow
@@ -184,6 +186,7 @@ class OmenSubgraphHandler(metaclass=SingletonMeta):
         condition_id_in: list[HexBytes] | None = None,
         id_in: list[str] | None = None,
         excluded_questions: set[str] | None = None,
+        collateral_token_address_in: tuple[ChecksumAddress, ...] | None = None,
     ) -> dict[str, t.Any]:
         where_stms: dict[str, t.Any] = {
             "isPendingArbitration": False,
@@ -193,6 +196,11 @@ class OmenSubgraphHandler(metaclass=SingletonMeta):
             "condition_": {},
         }
 
+        if collateral_token_address_in:
+            where_stms["collateralToken_in"] = [
+                x.lower() for x in collateral_token_address_in
+            ]
+
         if creator:
             where_stms["creator"] = creator
 
@@ -333,6 +341,12 @@ class OmenSubgraphHandler(metaclass=SingletonMeta):
         sort_by_field: FieldPath | None = None,
         sort_direction: str | None = None,
         outcomes: list[str] = [OMEN_TRUE_OUTCOME, OMEN_FALSE_OUTCOME],
+        # TODO: Agents don't know how to convert value between other tokens, we assume 1 unit = 1xDai = $1 (for example if market would be in wETH, betting 1 unit of wETH would be crazy :D)
+        collateral_token_address_in: tuple[ChecksumAddress, ...]
+        | None = (
+            WrappedxDaiContract().address,
+            sDaiContract().address,
+        ),
     ) -> t.List[OmenMarket]:
         """
         Complete method to fetch Omen binary markets with various filters, use `get_omen_binary_markets_simple` for simplified version that uses FilterBy and SortBy enums.
@@ -350,6 +364,7 @@ class OmenSubgraphHandler(metaclass=SingletonMeta):
             id_in=id_in,
             excluded_questions=excluded_questions,
             liquidity_bigger_than=liquidity_bigger_than,
+            collateral_token_address_in=collateral_token_address_in,
         )
 
         # These values can not be set to `None`, but they can be omitted.

prediction_market_agent_tooling/markets/polymarket/polymarket.py

@@ -41,7 +41,8 @@ class PolymarketAgentMarket(AgentMarket):
             volume=None,
         )
 
-    def get_tiny_bet_amount(self) -> BetAmount:
+    @classmethod
+    def get_tiny_bet_amount(cls) -> BetAmount:
         raise NotImplementedError("TODO: Implement to allow betting on Polymarket.")
 
     def place_bet(self, outcome: bool, amount: BetAmount) -> None: