prediction-market-agent-tooling 0.57.16.dev311__py3-none-any.whl → 0.57.18__py3-none-any.whl

prediction_market_agent_tooling/markets/omen/omen_constants.py

@@ -0,0 +1,8 @@
+from web3 import Web3
+
+WRAPPED_XDAI_CONTRACT_ADDRESS = Web3.to_checksum_address(
+    "0xe91d153e0b41518a2ce8dd3d7944fa863463a97d"
+)
+SDAI_CONTRACT_ADDRESS = Web3.to_checksum_address(
+    "0xaf204776c7245bF4147c2612BF6e5972Ee483701"
+)

prediction_market_agent_tooling/markets/omen/omen_contracts.py

@@ -31,6 +31,10 @@ from prediction_market_agent_tooling.markets.omen.data_models import (
     RealitioLogNewQuestionEvent,
     format_realitio_question,
 )
+from prediction_market_agent_tooling.markets.omen.omen_constants import (
+    SDAI_CONTRACT_ADDRESS,
+    WRAPPED_XDAI_CONTRACT_ADDRESS,
+)
 from prediction_market_agent_tooling.tools.contract import (
     ContractDepositableWrapperERC20OnGnosisChain,
     ContractERC20OnGnosisChain,
@@ -419,18 +423,26 @@ class OmenFixedProductMarketMakerContract(ContractOnGnosisChain):
         )
 
 
-class WrappedxDaiContract(ContractDepositableWrapperERC20OnGnosisChain):
+class GNOContract(ContractERC20OnGnosisChain):
     address: ChecksumAddress = Web3.to_checksum_address(
-        "0xe91d153e0b41518a2ce8dd3d7944fa863463a97d"
+        "0x9c58bacc331c9aa871afd802db6379a98e80cedb"
     )
 
 
-class sDaiContract(ContractERC4626OnGnosisChain):
+class WETHContract(ContractERC20OnGnosisChain):
     address: ChecksumAddress = Web3.to_checksum_address(
-        "0xaf204776c7245bF4147c2612BF6e5972Ee483701"
+        "0x6a023ccd1ff6f2045c3309768ead9e68f978f6e1"
     )
 
 
+class WrappedxDaiContract(ContractDepositableWrapperERC20OnGnosisChain):
+    address: ChecksumAddress = WRAPPED_XDAI_CONTRACT_ADDRESS
+
+
+class sDaiContract(ContractERC4626OnGnosisChain):
+    address: ChecksumAddress = SDAI_CONTRACT_ADDRESS
+
+
 OMEN_DEFAULT_MARKET_FEE_PERC = 0.02  # 2% fee from the buying shares amount.
 REALITY_DEFAULT_FINALIZATION_TIMEOUT = timedelta(days=3)
 

prediction_market_agent_tooling/markets/omen/omen_resolving.py

@@ -50,7 +50,7 @@ def claim_bonds_on_realitio_questions(
         except Exception as e:
             if not skip_failed:
                 raise e
-            logger.error(
+            logger.warning(
                 f"Failed to claim bond for {question.url=}, {question.questionId=}: {e}"
             )
 
@@ -203,7 +203,7 @@ def omen_submit_answer_market_tx(
     web3: Web3 | None = None,
 ) -> None:
     """
-    After the answer is submitted, there is 24h waiting period where the answer can be challenged by others.
+    After the answer is submitted, there is waiting period where the answer can be challenged by others.
     And after the period is over, you need to resolve the market using `omen_resolve_market_tx`.
     """
     realitio_contract = OmenRealitioContract()
@@ -224,7 +224,7 @@ def omen_submit_invalid_answer_market_tx(
     web3: Web3 | None = None,
 ) -> None:
     """
-    After the answer is submitted, there is 24h waiting period where the answer can be challenged by others.
+    After the answer is submitted, there is waiting period where the answer can be challenged by others.
     And after the period is over, you need to resolve the market using `omen_resolve_market_tx`.
     """
     realitio_contract = OmenRealitioContract()

prediction_market_agent_tooling/markets/seer/data_models.py

@@ -1,6 +1,33 @@
+import typing as t
+
+from eth_typing import HexAddress
 from pydantic import BaseModel, ConfigDict, Field
+from web3.constants import ADDRESS_ZERO
+
+from prediction_market_agent_tooling.gtypes import HexBytes, Wei
+
+
+class CreateCategoricalMarketsParams(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
 
-from prediction_market_agent_tooling.gtypes import HexBytes
+    market_name: str = Field(..., alias="marketName")
+    outcomes: list[str]
+    # Only relevant for scalar markets
+    question_start: str = Field(alias="questionStart", default="")
+    question_end: str = Field(alias="questionEnd", default="")
+    outcome_type: str = Field(alias="outcomeType", default="")
+
+    # Not needed for non-conditional markets.
+    parent_outcome: int = Field(alias="parentOutcome", default=0)
+    parent_market: HexAddress = Field(alias="parentMarket", default=ADDRESS_ZERO)
+
+    category: str
+    lang: str
+    lower_bound: int = Field(alias="lowerBound", default=0)
+    upper_bound: int = Field(alias="upperBound", default=0)
+    min_bond: Wei = Field(..., alias="minBond")
+    opening_time: int = Field(..., alias="openingTime")
+    token_names: list[str] = Field(..., alias="tokenNames")
 
 
 class SeerParentMarket(BaseModel):
@@ -13,8 +40,11 @@ class SeerMarket(BaseModel):
     id: HexBytes
     title: str = Field(alias="marketName")
     outcomes: list[str]
-    parent_market: SeerParentMarket | None = Field(alias="parentMarket")
     wrapped_tokens: list[HexBytes] = Field(alias="wrappedTokens")
+    parent_outcome: int = Field(alias="parentOutcome")
+    parent_market: t.Optional[SeerParentMarket] = Field(
+        alias="parentMarket", default=None
+    )
 
 
 class SeerToken(BaseModel):
@@ -29,3 +59,12 @@ class SeerPool(BaseModel):
     liquidity: int
     token0: SeerToken
     token1: SeerToken
+
+
+class NewMarketEvent(BaseModel):
+    market: HexAddress
+    marketName: str
+    parentMarket: HexAddress
+    conditionId: HexBytes
+    questionId: HexBytes
+    questionsIds: list[HexBytes]

prediction_market_agent_tooling/markets/seer/seer.py

@@ -0,0 +1,94 @@
+from eth_typing import ChecksumAddress
+from web3 import Web3
+from web3.types import TxReceipt
+
+from prediction_market_agent_tooling.config import APIKeys
+from prediction_market_agent_tooling.gtypes import xDai
+from prediction_market_agent_tooling.markets.seer.data_models import NewMarketEvent
+from prediction_market_agent_tooling.markets.seer.seer_contracts import (
+    SeerMarketFactory,
+)
+from prediction_market_agent_tooling.tools.contract import (
+    init_collateral_token_contract,
+    to_gnosis_chain_contract,
+)
+from prediction_market_agent_tooling.tools.datetime_utc import DatetimeUTC
+from prediction_market_agent_tooling.tools.tokens.auto_deposit import (
+    auto_deposit_collateral_token,
+)
+from prediction_market_agent_tooling.tools.web3_utils import xdai_to_wei
+
+
+def seer_create_market_tx(
+    api_keys: APIKeys,
+    initial_funds: xDai,
+    question: str,
+    opening_time: DatetimeUTC,
+    language: str,
+    outcomes: list[str],
+    auto_deposit: bool,
+    category: str,
+    min_bond_xdai: xDai,
+    web3: Web3 | None = None,
+) -> ChecksumAddress:
+    web3 = web3 or SeerMarketFactory.get_web3()  # Default to Gnosis web3.
+    initial_funds_wei = xdai_to_wei(initial_funds)
+
+    factory_contract = SeerMarketFactory()
+    collateral_token_address = factory_contract.collateral_token(web3=web3)
+    collateral_token_contract = to_gnosis_chain_contract(
+        init_collateral_token_contract(collateral_token_address, 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,
+        )
+
+    # In case of ERC4626, obtained (for example) sDai out of xDai could be lower than the `amount_wei`, so we need to handle it.
+    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.
+    params = factory_contract.build_market_params(
+        market_question=question,
+        outcomes=outcomes,
+        opening_time=opening_time,
+        language=language,
+        category=category,
+        min_bond_xdai=min_bond_xdai,
+    )
+    tx_receipt = factory_contract.create_categorical_market(
+        api_keys=api_keys, params=params, web3=web3
+    )
+
+    # ToDo - Add liquidity to market on Swapr (https://github.com/gnosis/prediction-market-agent-tooling/issues/497)
+    market_address = extract_market_address_from_tx(
+        factory_contract=factory_contract, tx_receipt=tx_receipt, web3=web3
+    )
+    return market_address
+
+
+def extract_market_address_from_tx(
+    factory_contract: SeerMarketFactory, tx_receipt: TxReceipt, web3: Web3
+) -> ChecksumAddress:
+    """We extract the newly created market from the NewMarket event emitted in the transaction."""
+    event_logs = (
+        factory_contract.get_web3_contract(web3=web3)
+        .events.NewMarket()
+        .process_receipt(tx_receipt)
+    )
+    new_market_event = NewMarketEvent(**event_logs[0]["args"])
+    return Web3.to_checksum_address(new_market_event.market)

prediction_market_agent_tooling/markets/seer/seer_contracts.py

@@ -0,0 +1,76 @@
+import os
+
+from web3 import Web3
+from web3.types import TxReceipt
+
+from prediction_market_agent_tooling.config import APIKeys
+from prediction_market_agent_tooling.gtypes import ABI, ChecksumAddress, xDai
+from prediction_market_agent_tooling.markets.seer.data_models import (
+    CreateCategoricalMarketsParams,
+)
+from prediction_market_agent_tooling.tools.contract import (
+    ContractOnGnosisChain,
+    abi_field_validator,
+)
+from prediction_market_agent_tooling.tools.datetime_utc import DatetimeUTC
+from prediction_market_agent_tooling.tools.web3_utils import xdai_to_wei
+
+
+class SeerMarketFactory(ContractOnGnosisChain):
+    # https://gnosisscan.io/address/0x83183da839ce8228e31ae41222ead9edbb5cdcf1#code.
+    abi: ABI = abi_field_validator(
+        os.path.join(
+            os.path.dirname(os.path.realpath(__file__)),
+            "../../abis/seer_market_factory.abi.json",
+        )
+    )
+    address: ChecksumAddress = Web3.to_checksum_address(
+        "0x83183da839ce8228e31ae41222ead9edbb5cdcf1"
+    )
+
+    @staticmethod
+    def build_market_params(
+        market_question: str,
+        outcomes: list[str],
+        opening_time: DatetimeUTC,
+        min_bond_xdai: xDai,
+        language: str = "en_US",
+        category: str = "misc",
+    ) -> CreateCategoricalMarketsParams:
+        return CreateCategoricalMarketsParams(
+            market_name=market_question,
+            token_names=[
+                o.upper() for o in outcomes
+            ],  # Following usual token names on Seer (YES,NO).
+            min_bond=xdai_to_wei(min_bond_xdai),
+            opening_time=int(opening_time.timestamp()),
+            outcomes=outcomes,
+            lang=language,
+            category=category,
+        )
+
+    def market_count(self, web3: Web3 | None = None) -> int:
+        count: int = self.call("marketCount", web3=web3)
+        return count
+
+    def market_at_index(self, index: int, web3: Web3 | None = None) -> ChecksumAddress:
+        market_address: str = self.call("markets", function_params=[index], web3=web3)
+        return Web3.to_checksum_address(market_address)
+
+    def collateral_token(self, web3: Web3 | None = None) -> ChecksumAddress:
+        collateral_token_address: str = self.call("collateralToken", web3=web3)
+        return Web3.to_checksum_address(collateral_token_address)
+
+    def create_categorical_market(
+        self,
+        api_keys: APIKeys,
+        params: CreateCategoricalMarketsParams,
+        web3: Web3 | None = None,
+    ) -> TxReceipt:
+        receipt_tx = self.send(
+            api_keys=api_keys,
+            function_name="createCategoricalMarket",
+            function_params=[params.model_dump(by_alias=True)],
+            web3=web3,
+        )
+        return receipt_tx

prediction_market_agent_tooling/markets/seer/seer_subgraph_handler.py

@@ -46,6 +46,7 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
             markets_field.factory,
             markets_field.creator,
             markets_field.marketName,
+            markets_field.parentOutcome,
             markets_field.outcomes,
             markets_field.parentMarket.id,
             markets_field.finalizeTs,
@@ -126,7 +127,7 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
         ]
         return fields
 
-    def get_pools_for_market(self, market: SeerMarket) -> list[SeerPool]:
+    def get_swapr_pools_for_market(self, market: SeerMarket) -> list[SeerPool]:
         # We iterate through the wrapped tokens and put them in a where clause so that we hit the subgraph endpoint just once.
         wheres = []
         for wrapped_token in market.wrapped_tokens:

prediction_market_agent_tooling/monitor/monitor.py

@@ -378,7 +378,7 @@ def monitor_market_outcome_bias(
 
     if len(df) > 0:
         st.altair_chart(
-            alt.layer(open_chart, resolved_chart).interactive(),  # type: ignore # Doesn't expect `LayerChart`, but `Chart`, yet it works.
+            alt.layer(open_chart, resolved_chart).interactive(),
             use_container_width=True,
         )
 

prediction_market_agent_tooling/monitor/monitor_app.py

@@ -1,5 +1,5 @@
 import typing as t
-from datetime import date, datetime, timedelta
+from datetime import datetime, timedelta
 
 import streamlit as st
 
@@ -105,13 +105,9 @@ def monitor_app(
     start_time: DatetimeUTC | None = (
         DatetimeUTC.from_datetime(
             datetime.combine(
-                t.cast(
-                    # This will be always a date for us, so casting.
-                    date,
-                    st.date_input(
-                        "Start time",
-                        value=utcnow() - timedelta(weeks=settings.PAST_N_WEEKS),
-                    ),
+                st.date_input(
+                    "Start time",
+                    value=utcnow() - timedelta(weeks=settings.PAST_N_WEEKS),
                 ),
                 datetime.min.time(),
             )

prediction_market_agent_tooling/tools/contract.py

@@ -22,11 +22,7 @@ from prediction_market_agent_tooling.gtypes import (
 )
 from prediction_market_agent_tooling.tools.data_models import MessageContainer
 from prediction_market_agent_tooling.tools.hexbytes_custom import HexBytes
-from prediction_market_agent_tooling.tools.utils import (
-    BPS_CONSTANT,
-    DatetimeUTC,
-    should_not_happen,
-)
+from prediction_market_agent_tooling.tools.utils import BPS_CONSTANT, DatetimeUTC
 from prediction_market_agent_tooling.tools.web3_utils import (
     call_function_on_contract,
     send_function_on_contract_tx,
@@ -798,99 +794,6 @@ def init_collateral_token_contract(
         )
 
 
-def auto_deposit_collateral_token(
-    collateral_token_contract: ContractERC20BaseClass,
-    amount_wei: Wei,
-    api_keys: APIKeys,
-    web3: Web3 | None,
-) -> None:
-    if isinstance(collateral_token_contract, ContractERC4626BaseClass):
-        auto_deposit_erc4626(collateral_token_contract, amount_wei, api_keys, web3)
-
-    elif isinstance(
-        collateral_token_contract, ContractDepositableWrapperERC20BaseClass
-    ):
-        auto_deposit_depositable_wrapper_erc20(
-            collateral_token_contract, amount_wei, api_keys, web3
-        )
-
-    elif isinstance(collateral_token_contract, ContractERC20BaseClass):
-        if (
-            collateral_token_contract.balanceOf(
-                for_address=api_keys.bet_from_address, web3=web3
-            )
-            < amount_wei
-        ):
-            raise ValueError(
-                f"Not enough of the collateral token, but it's not a wrapper token that we can deposit automatically."
-            )
-
-    else:
-        should_not_happen("Unsupported ERC20 contract type.")
-
-
-def auto_deposit_depositable_wrapper_erc20(
-    collateral_token_contract: ContractDepositableWrapperERC20BaseClass,
-    amount_wei: Wei,
-    api_keys: APIKeys,
-    web3: Web3 | None,
-) -> None:
-    collateral_token_balance = collateral_token_contract.balanceOf(
-        for_address=api_keys.bet_from_address, web3=web3
-    )
-
-    # If we have enough of the collateral token, we don't need to deposit.
-    if collateral_token_balance >= amount_wei:
-        return
-
-    # If we don't have enough, we need to deposit the difference.
-    left_to_deposit = Wei(amount_wei - collateral_token_balance)
-    collateral_token_contract.deposit(api_keys, left_to_deposit, web3=web3)
-
-
-def auto_deposit_erc4626(
-    collateral_token_contract: ContractERC4626BaseClass,
-    asset_amount_wei: Wei,
-    api_keys: APIKeys,
-    web3: Web3 | None,
-) -> None:
-    for_address = api_keys.bet_from_address
-    collateral_token_balance_in_shares = collateral_token_contract.balanceOf(
-        for_address=for_address, web3=web3
-    )
-    asset_amount_wei_in_shares = collateral_token_contract.convertToShares(
-        asset_amount_wei, web3
-    )
-
-    # If we have enough shares, we don't need to deposit.
-    if collateral_token_balance_in_shares >= asset_amount_wei_in_shares:
-        return
-
-    # If we need to deposit into erc4626, we first need to have enough of the asset token.
-    asset_token_contract = collateral_token_contract.get_asset_token_contract(web3=web3)
-
-    # If the asset token is Depositable Wrapper ERC-20, we can deposit it, in case we don't have enough.
-    if (
-        collateral_token_contract.get_asset_token_balance(for_address, web3)
-        < asset_amount_wei
-    ):
-        if isinstance(asset_token_contract, ContractDepositableWrapperERC20BaseClass):
-            auto_deposit_depositable_wrapper_erc20(
-                asset_token_contract, asset_amount_wei, api_keys, web3
-            )
-        else:
-            raise ValueError(
-                "Not enough of the asset token, but it's not a depositable wrapper token that we can deposit automatically."
-            )
-
-    # Finally, we can deposit the asset token into the erc4626 vault.
-    collateral_token_balance_in_assets = collateral_token_contract.convertToAssets(
-        collateral_token_balance_in_shares, web3
-    )
-    left_to_deposit = Wei(asset_amount_wei - collateral_token_balance_in_assets)
-    collateral_token_contract.deposit_asset_token(left_to_deposit, api_keys, web3)
-
-
 def to_gnosis_chain_contract(
     contract: ContractERC20BaseClass,
 ) -> ContractERC20OnGnosisChain:

prediction_market_agent_tooling/tools/cow/cow_order.py

@@ -0,0 +1,133 @@
+import asyncio
+from datetime import timedelta
+
+import httpx
+from cowdao_cowpy import swap_tokens
+from cowdao_cowpy.common.chains import Chain
+from cowdao_cowpy.common.config import SupportedChainId
+from cowdao_cowpy.common.constants import CowContractAddress
+from cowdao_cowpy.order_book.api import OrderBookApi
+from cowdao_cowpy.order_book.config import Envs, OrderBookAPIConfigFactory
+from cowdao_cowpy.order_book.generated.model import (
+    Address,
+    OrderMetaData,
+    OrderQuoteRequest,
+    OrderQuoteSide1,
+    OrderQuoteSideKindSell,
+    OrderStatus,
+    TokenAmount,
+)
+from eth_account.signers.local import LocalAccount
+from eth_typing.evm import ChecksumAddress
+from web3 import Web3
+from web3.types import Wei
+
+from prediction_market_agent_tooling.config import APIKeys
+from prediction_market_agent_tooling.gtypes import ChecksumAddress, Wei, wei_type
+from prediction_market_agent_tooling.loggers import logger
+from prediction_market_agent_tooling.tools.contract import ContractERC20OnGnosisChain
+from prediction_market_agent_tooling.tools.utils import utcnow
+
+
+def get_order_book_api(env: Envs, chain: Chain) -> OrderBookApi:
+    chain_id = SupportedChainId(chain.value[0])
+    return OrderBookApi(OrderBookAPIConfigFactory.get_config(env, chain_id))
+
+
+def get_buy_token_amount(
+    amount_wei: Wei,
+    sell_token: ChecksumAddress,
+    buy_token: ChecksumAddress,
+    chain: Chain = Chain.GNOSIS,
+    env: Envs = "prod",
+) -> Wei:
+    order_book_api = get_order_book_api(env, chain)
+    order_quote_request = OrderQuoteRequest(
+        sellToken=Address(sell_token),
+        buyToken=Address(buy_token),
+        from_=Address(
+            "0x1234567890abcdef1234567890abcdef12345678"
+        ),  # Just random address, doesn't matter.
+    )
+    order_side = OrderQuoteSide1(
+        kind=OrderQuoteSideKindSell.sell,
+        sellAmountBeforeFee=TokenAmount(str(amount_wei)),
+    )
+    order_quote = asyncio.run(
+        order_book_api.post_quote(order_quote_request, order_side)
+    )
+    return wei_type(order_quote.quote.buyAmount.root)
+
+
+def swap_tokens_waiting(
+    amount_wei: Wei,
+    sell_token: ChecksumAddress,
+    buy_token: ChecksumAddress,
+    api_keys: APIKeys,
+    chain: Chain = Chain.GNOSIS,
+    env: Envs = "prod",
+    web3: Web3 | None = None,
+) -> OrderMetaData:
+    account = api_keys.get_account()
+
+    # Approve the CoW Swap Vault Relayer to get the sell token.
+    ContractERC20OnGnosisChain(address=sell_token).approve(
+        api_keys,
+        Web3.to_checksum_address(CowContractAddress.VAULT_RELAYER.value),
+        amount_wei=amount_wei,
+        web3=web3,
+    )
+
+    # CoW library uses async, so we need to wrap the call in asyncio.run for us to use it.
+    return asyncio.run(
+        swap_tokens_waiting_async(
+            amount_wei, sell_token, buy_token, account, chain, env
+        )
+    )
+
+
+async def swap_tokens_waiting_async(
+    amount_wei: Wei,
+    sell_token: ChecksumAddress,
+    buy_token: ChecksumAddress,
+    account: LocalAccount,
+    chain: Chain,
+    env: Envs,
+    timeout: timedelta = timedelta(seconds=60),
+) -> OrderMetaData:
+    order = await swap_tokens(
+        amount=amount_wei,
+        sell_token=sell_token,
+        buy_token=buy_token,
+        account=account,
+        chain=chain,
+        env=env,
+    )
+    logger.info(f"Order created: {order}")
+    start_time = utcnow()
+
+    while True:
+        async with httpx.AsyncClient() as client:
+            response = await client.get(order.url)
+            order_metadata = OrderMetaData.model_validate(response.json())
+
+        if order_metadata.status == OrderStatus.fulfilled:
+            logger.info(f"Order {order.uid} ({order.url}) completed.")
+            return order_metadata
+
+        elif order_metadata.status in (
+            OrderStatus.cancelled,
+            OrderStatus.expired,
+        ):
+            raise ValueError(f"Order {order.uid} failed. {order.url}")
+
+        if utcnow() - start_time > timeout:
+            raise TimeoutError(
+                f"Timeout waiting for order {order.uid} to be completed. {order.url}"
+            )
+
+        logger.info(
+            f"Order status of {order.uid} ({order.url}): {order_metadata.status}, waiting..."
+        )
+
+        await asyncio.sleep(3.14)