prediction-market-agent-tooling 0.67.2__py3-none-any.whl → 0.67.4__py3-none-any.whl

prediction_market_agent_tooling/markets/seer/seer_subgraph_handler.py

@@ -1,5 +1,6 @@
 import sys
 import typing as t
+from collections import defaultdict
 from enum import Enum
 from typing import Any
 
@@ -15,6 +16,7 @@ from prediction_market_agent_tooling.deploy.constants import (
 from prediction_market_agent_tooling.gtypes import ChecksumAddress, Wei
 from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.markets.agent_market import (
+    ConditionalFilterType,
     FilterBy,
     QuestionType,
     SortBy,
@@ -22,9 +24,14 @@ from prediction_market_agent_tooling.markets.agent_market import (
 from prediction_market_agent_tooling.markets.base_subgraph_handler import (
     BaseSubgraphHandler,
 )
-from prediction_market_agent_tooling.markets.seer.data_models import SeerMarket
+from prediction_market_agent_tooling.markets.seer.data_models import (
+    SeerMarket,
+    SeerMarketQuestions,
+    SeerMarketWithQuestions,
+)
 from prediction_market_agent_tooling.markets.seer.subgraph_data_models import SeerPool
 from prediction_market_agent_tooling.tools.hexbytes_custom import HexBytes
+from prediction_market_agent_tooling.tools.singleton import SingletonMeta
 from prediction_market_agent_tooling.tools.utils import to_int_timestamp, utcnow
 from prediction_market_agent_tooling.tools.web3_utils import unwrap_generic_value
 
@@ -85,12 +92,6 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
             markets_field.upperBound,
             markets_field.lowerBound,
             markets_field.templateId,
-            # TODO: On the Subgraph, `questions` field is a kind of sub-query, instead of a classic list of values.
-            # See how it is shown on their UI: https://thegraph.com/explorer/subgraphs/B4vyRqJaSHD8dRDb3BFRoAzuBK18c1QQcXq94JbxDxWH?view=Query&chain=arbitrum-one.
-            # And that doesn't work with subgrounds.
-            # markets_field.questions.question.id,
-            # markets_field.questions.question.finalize_ts,
-            # markets_field.questions.question.best_answer,
         ]
         if current_level < max_level:
             fields.extend(
@@ -132,8 +133,8 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
     def _build_where_statements(
         filter_by: FilterBy,
         outcome_supply_gt_if_open: Wei,
-        include_conditional_markets: bool = False,
         question_type: QuestionType = QuestionType.ALL,
+        conditional_filter_type: ConditionalFilterType = ConditionalFilterType.ONLY_NOT_CONDITIONAL,
         parent_market_id: HexBytes | None = None,
     ) -> dict[Any, Any]:
         now = to_int_timestamp(utcnow())
@@ -153,9 +154,6 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
             case _:
                 raise ValueError(f"Unknown filter {filter_by}")
 
-        if not include_conditional_markets:
-            and_stms["parentMarket"] = ADDRESS_ZERO.lower()
-
         if parent_market_id:
             and_stms["parentMarket"] = parent_market_id.hex().lower()
 
@@ -196,9 +194,21 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
                 }
             )
 
-        # If none specified, don't add any template/outcome filters (returns all types)
+        # Build filters for conditional_filter type
+        conditional_filter = {}
+        match conditional_filter_type:
+            case ConditionalFilterType.ONLY_CONDITIONAL:
+                conditional_filter["parentMarket_not"] = ADDRESS_ZERO.lower()
+            case ConditionalFilterType.ONLY_NOT_CONDITIONAL:
+                conditional_filter["parentMarket"] = ADDRESS_ZERO.lower()
+            case ConditionalFilterType.ALL:
+                pass
+            case _:
+                raise ValueError(
+                    f"Unknown conditional filter {conditional_filter_type}"
+                )
 
-        all_filters = [and_stms] + outcome_filters if and_stms else outcome_filters
+        all_filters = outcome_filters + [and_stms, conditional_filter]
         where_stms: dict[str, t.Any] = {"and": all_filters}
         return where_stms
 
@@ -235,9 +245,9 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
         limit: int | None = None,
         outcome_supply_gt_if_open: Wei = Wei(0),
         question_type: QuestionType = QuestionType.ALL,
-        include_conditional_markets: bool = False,
+        conditional_filter_type: ConditionalFilterType = ConditionalFilterType.ONLY_NOT_CONDITIONAL,
         parent_market_id: HexBytes | None = None,
-    ) -> list[SeerMarket]:
+    ) -> list[SeerMarketWithQuestions]:
         sort_direction, sort_by_field = self._build_sort_params(sort_by)
 
         where_stms = self._build_where_statements(
@@ -245,7 +255,7 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
             outcome_supply_gt_if_open=outcome_supply_gt_if_open,
             parent_market_id=parent_market_id,
             question_type=question_type,
-            include_conditional_markets=include_conditional_markets,
+            conditional_filter_type=conditional_filter_type,
         )
 
         # These values can not be set to `None`, but they can be omitted.
@@ -264,12 +274,65 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
         )
         fields = self._get_fields_for_markets(markets_field)
         markets = self.do_query(fields=fields, pydantic_model=SeerMarket)
-        return markets
+        market_ids = [m.id for m in markets]
+        # We fetch questions from all markets and all parents in one go
+        parent_market_ids = [
+            m.parent_market.id for m in markets if m.parent_market is not None
+        ]
+        q = SeerQuestionsCache(seer_subgraph_handler=self)
+        q.fetch_questions(list(set(market_ids + parent_market_ids)))
+
+        # Create SeerMarketWithQuestions for each market
+        return [
+            SeerMarketWithQuestions(
+                **m.model_dump(), questions=q.market_id_to_questions[m.id]
+            )
+            for m in markets
+        ]
 
-    def get_market_by_id(self, market_id: HexBytes) -> SeerMarket:
+    def get_questions_for_markets(
+        self, market_ids: list[HexBytes]
+    ) -> list[SeerMarketQuestions]:
+        where = unwrap_generic_value(
+            {"market_in": [market_id.hex().lower() for market_id in market_ids]}
+        )
+        markets_field = self.seer_subgraph.Query.marketQuestions(where=where)
+        fields = self._get_fields_for_questions(markets_field)
+        questions = self.do_query(fields=fields, pydantic_model=SeerMarketQuestions)
+        return questions
+
+    def get_market_by_id(self, market_id: HexBytes) -> SeerMarketWithQuestions:
         markets_field = self.seer_subgraph.Query.market(id=market_id.hex().lower())
         fields = self._get_fields_for_markets(markets_field)
         markets = self.do_query(fields=fields, pydantic_model=SeerMarket)
+        if len(markets) != 1:
+            raise ValueError(
+                f"Fetched wrong number of markets. Expected 1 but got {len(markets)}"
+            )
+        q = SeerQuestionsCache(self)
+        q.fetch_questions([market_id])
+        questions = q.market_id_to_questions[market_id]
+        s = SeerMarketWithQuestions.model_validate(
+            markets[0].model_dump() | {"questions": questions}
+        )
+        return s
+
+    def _get_fields_for_questions(self, questions_field: FieldPath) -> list[FieldPath]:
+        fields = [
+            questions_field.question.id,
+            questions_field.question.best_answer,
+            questions_field.question.finalize_ts,
+            questions_field.market.id,
+        ]
+        return fields
+
+    def get_market_by_wrapped_token(self, token: ChecksumAddress) -> SeerMarket:
+        where_stms = {"wrappedTokens_contains": [token]}
+        markets_field = self.seer_subgraph.Query.markets(
+            where=unwrap_generic_value(where_stms)
+        )
+        fields = self._get_fields_for_markets(markets_field)
+        markets = self.do_query(fields=fields, pydantic_model=SeerMarket)
         if len(markets) != 1:
             raise ValueError(
                 f"Fetched wrong number of markets. Expected 1 but got {len(markets)}"
@@ -328,3 +391,44 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
             # We select the first one
             return pools[0]
         return None
+
+
+class SeerQuestionsCache(metaclass=SingletonMeta):
+    """A singleton cache for storing and retrieving Seer market questions.
+
+    This class provides an in-memory cache for Seer market questions, preventing
+    redundant subgraph queries by maintaining a mapping of market IDs to their
+    associated questions. It implements the singleton pattern to ensure a single
+    cache instance is used throughout the agent run.
+
+    Attributes:
+        market_id_to_questions: A dictionary mapping market IDs to lists of SeerMarketQuestions
+        seer_subgraph_handler: Handler for interacting with the Seer subgraph
+    """
+
+    def __init__(self, seer_subgraph_handler: SeerSubgraphHandler | None = None):
+        self.market_id_to_questions: dict[
+            HexBytes, list[SeerMarketQuestions]
+        ] = defaultdict(list)
+        self.seer_subgraph_handler = seer_subgraph_handler or SeerSubgraphHandler()
+
+    def fetch_questions(self, market_ids: list[HexBytes]) -> None:
+        filtered_list = [
+            market_id
+            for market_id in market_ids
+            if market_id not in self.market_id_to_questions
+        ]
+        if not filtered_list:
+            return
+
+        questions = self.seer_subgraph_handler.get_questions_for_markets(filtered_list)
+        # Group questions by market_id
+        questions_by_market: dict[HexBytes, list[SeerMarketQuestions]] = defaultdict(
+            list
+        )
+        for q in questions:
+            questions_by_market[q.market.id].append(q)
+
+        # Update the cache with the new questions for each market
+        for market_id, market_questions in questions_by_market.items():
+            self.market_id_to_questions[market_id] = market_questions

prediction_market_agent_tooling/markets/seer/swap_pool_handler.py

@@ -71,7 +71,10 @@ class SwapPoolHandler:
         price_outcome_token = PriceManager.build(
             HexBytes(HexStr(self.market_id))
         ).get_token_price_from_pools(token=outcome_token)
-        if not price_outcome_token:
+        if (
+            not price_outcome_token
+            or not price_outcome_token.priceOfCollateralInAskingToken
+        ):
             raise ValueError(
                 f"Could not find price for {outcome_token=} and {self.collateral_token_address}"
             )

prediction_market_agent_tooling/tools/contract.py

@@ -413,6 +413,20 @@ class ContractERC4626BaseClass(ContractERC20BaseClass):
         return self.convertToShares(amount, web3=web3)
 
 
+class ContractWrapped1155BaseClass(ContractERC20BaseClass):
+    """Wrapped 1155 contract from Seer (https://gnosisscan.io/address/0x2f9c49974ad8b9b31424d9dc812667b16310ca50#readContract)
+    Source code - https://github.com/seer-pm/demo/blob/main/contracts/src/interaction/1155-to-20/Wrapped1155Factory.sol#L224
+    This contract inherits from ERC20 and contains additional properties, such as multiToken (conditional Token contract implementation)
+    and tokenId (token identifier). Goal is to wrap individual tokens into a standalone ERC20 token.
+    """
+
+    abi: ABI = abi_field_validator(
+        os.path.join(
+            os.path.dirname(os.path.realpath(__file__)), "../abis/erc1155.abi.json"
+        )
+    )
+
+
 class OwnableContract(ContractBaseClass):
     abi: ABI = abi_field_validator(
         os.path.join(
@@ -533,6 +547,12 @@ class ContractDepositableWrapperERC20OnGnosisChain(
     """
 
 
+class ContractWrapped1155OnGnosisChain(
+    ContractWrapped1155BaseClass, ContractERC20OnGnosisChain
+):
+    pass
+
+
 class ContractERC4626OnGnosisChain(
     ContractERC4626BaseClass, ContractERC20OnGnosisChain
 ):
@@ -626,6 +646,11 @@ def contract_implements_function(
                 function_name=function_name,
                 web3=web3,
                 function_arg_types=function_arg_types,
+            ) or seer_minimal_proxy_implements_function(
+                contract_address=contract_address,
+                function_name=function_name,
+                web3=web3,
+                function_arg_types=function_arg_types,
             )
 
     return implements
@@ -654,6 +679,31 @@ def minimal_proxy_implements_function(
         return False
 
 
+def seer_minimal_proxy_implements_function(
+    contract_address: ChecksumAddress,
+    function_name: str,
+    web3: Web3,
+    function_arg_types: list[str] | None = None,
+) -> bool:
+    try:
+        # Read address between specific indices to find logic contract
+        bytecode = web3.eth.get_code(contract_address)
+        logic_contract_address = bytecode[11:31]
+        if not Web3.is_address(logic_contract_address):
+            return False
+
+        return contract_implements_function(
+            Web3.to_checksum_address(logic_contract_address),
+            function_name=function_name,
+            web3=web3,
+            function_arg_types=function_arg_types,
+            look_for_proxy_contract=False,
+        )
+    except DecodingError:
+        logger.info("Error decoding contract address on seer minimal proxy")
+        return False
+
+
 def init_collateral_token_contract(
     address: ChecksumAddress, web3: Web3 | None
 ) -> ContractERC20BaseClass:
@@ -673,6 +723,13 @@ def init_collateral_token_contract(
     ):
         return ContractDepositableWrapperERC20BaseClass(address=address)
 
+    elif contract_implements_function(
+        address,
+        "multiToken",
+        web3=web3,
+    ):
+        return ContractWrapped1155BaseClass(address=address)
+
     elif contract_implements_function(
         address,
         "balanceOf",
@@ -694,6 +751,8 @@ def to_gnosis_chain_contract(
         return ContractERC4626OnGnosisChain(address=contract.address)
     elif isinstance(contract, ContractDepositableWrapperERC20BaseClass):
         return ContractDepositableWrapperERC20OnGnosisChain(address=contract.address)
+    elif isinstance(contract, ContractWrapped1155BaseClass):
+        return ContractWrapped1155OnGnosisChain(address=contract.address)
     elif isinstance(contract, ContractERC20BaseClass):
         return ContractERC20OnGnosisChain(address=contract.address)
     else:

prediction_market_agent_tooling/tools/cow/cow_order.py

@@ -167,10 +167,13 @@ def handle_allowance(
     api_keys: APIKeys,
     sell_token: ChecksumAddress,
     amount_wei: Wei,
+    for_address: ChecksumAddress | None = None,
     web3: Web3 | None = None,
 ) -> None:
     # Approve the CoW Swap Vault Relayer to get the sell token only if allowance not sufficient.
-    for_address = Web3.to_checksum_address(CowContractAddress.VAULT_RELAYER.value)
+    for_address = for_address or Web3.to_checksum_address(
+        CowContractAddress.VAULT_RELAYER.value
+    )
     current_allowance = ContractERC20OnGnosisChain(address=sell_token).allowance(
         owner=api_keys.bet_from_address,
         for_address=for_address,

prediction_market_agent_tooling/tools/hexbytes_custom.py

@@ -60,6 +60,15 @@ class HexBytes(HexBytesBase, BaseHex):
         value = hex_str[2:] if hex_str.startswith("0x") else hex_str
         return super().fromhex(value)
 
+    def hex(
+        self,
+        sep: t.Union[str, bytes] | None = None,
+        bytes_per_sep: t.SupportsIndex = 1,
+    ) -> str:
+        """We enforce a 0x prefix."""
+        x = super().hex(sep, bytes_per_sep)  # type: ignore[arg-type]
+        return x if x.startswith("0x") else "0x" + x
+
     @classmethod
     def __eth_pydantic_validate__(
         cls, value: t.Any, info: ValidationInfo | None = None

prediction_market_agent_tooling/tools/httpx_cached_client.py

@@ -1,15 +1,17 @@
+from datetime import timedelta
+
 import hishel
 import httpx
 
 from prediction_market_agent_tooling.tools.singleton import SingletonMeta
 
-ONE_DAY_IN_SECONDS = 60 * 60 * 24
+ONE_DAY = timedelta(days=1)
 
 
 class HttpxCachedClient(metaclass=SingletonMeta):
-    def __init__(self, ttl: int = ONE_DAY_IN_SECONDS) -> None:
+    def __init__(self, ttl: timedelta = ONE_DAY) -> None:
         storage = hishel.FileStorage(
-            ttl=ttl,
+            ttl=ttl.total_seconds(),
             check_ttl_every=60,
         )
         controller = hishel.Controller(force_cache=True)

prediction_market_agent_tooling/tools/langfuse_client_utils.py

@@ -68,6 +68,7 @@ def get_traces_for_agent(
     client: Langfuse,
     to_timestamp: DatetimeUTC | None = None,
     tags: str | list[str] | None = None,
+    limit: int | None = None,
 ) -> list[TraceWithDetails]:
     """
     Fetch agent traces using pagination
@@ -98,6 +99,9 @@ def get_traces_for_agent(
         if has_output:
             agent_traces = [t for t in agent_traces if t.output is not None]
         all_agent_traces.extend(agent_traces)
+        if limit is not None and len(all_agent_traces) >= limit:
+            all_agent_traces = all_agent_traces[:limit]
+            break
     return all_agent_traces
 
 

prediction_market_agent_tooling/tools/rephrase.py

@@ -33,7 +33,7 @@ Output only the rephrased question.
 @tenacity.retry(stop=tenacity.stop_after_attempt(3), wait=tenacity.wait_fixed(1))
 @observe()
 @db_cache
-def rephrase_question_to_unconditioned(
+def rephrase_question_to_unconditional(
     question: str,
     parent_question: str,
     needed_parent_outcome: str,

prediction_market_agent_tooling/tools/singleton.py

@@ -8,16 +8,21 @@ class SingletonMeta(type, t.Generic[_T]):
     The Singleton class can be implemented in different ways in Python. Some
     possible methods include: base class, decorator, metaclass. We will use the
     metaclass because it is best suited for this purpose.
+
+    This version creates a unique instance for each unique set of __init__ arguments.
     """
 
-    _instances: dict[t.Any, _T] = {}
+    _instances: dict[
+        tuple[t.Any, tuple[t.Any, ...], tuple[tuple[str, t.Any], ...]], _T
+    ] = {}
 
     def __call__(self, *args: t.Any, **kwargs: t.Any) -> _T:
         """
-        Possible changes to the value of the `__init__` argument do not affect
-        the returned instance.
+        Different __init__ arguments will result in different instances.
         """
-        if self not in self._instances:
+        # Create a key based on the class, args, and kwargs (sorted for consistency)
+        key = (self, args, tuple(sorted(kwargs.items())))
+        if key not in self._instances:
             instance = super().__call__(*args, **kwargs)
-            self._instances[self] = instance
-        return self._instances[self]
+            self._instances[key] = instance
+        return self._instances[key]

prediction_market_agent_tooling/tools/tokens/auto_deposit.py

@@ -3,14 +3,22 @@ from web3 import Web3
 from prediction_market_agent_tooling.config import APIKeys
 from prediction_market_agent_tooling.gtypes import USD, Wei
 from prediction_market_agent_tooling.loggers import logger
+from prediction_market_agent_tooling.markets.seer.seer_contracts import GnosisRouter
+from prediction_market_agent_tooling.markets.seer.seer_subgraph_handler import (
+    SeerSubgraphHandler,
+)
 from prediction_market_agent_tooling.tools.contract import (
     ContractDepositableWrapperERC20BaseClass,
     ContractERC20BaseClass,
     ContractERC20OnGnosisChain,
     ContractERC4626BaseClass,
+    ContractWrapped1155BaseClass,
+    init_collateral_token_contract,
+    to_gnosis_chain_contract,
 )
 from prediction_market_agent_tooling.tools.cow.cow_order import (
     get_sell_token_amount,
+    handle_allowance,
     swap_tokens_waiting,
 )
 from prediction_market_agent_tooling.tools.tokens.main_token import KEEPING_ERC20_TOKEN
@@ -49,6 +57,9 @@ def auto_deposit_collateral_token(
             collateral_token_contract, collateral_amount_wei, api_keys, web3
         )
 
+    elif isinstance(collateral_token_contract, ContractWrapped1155BaseClass):
+        mint_full_set(collateral_token_contract, collateral_amount_wei, api_keys, web3)
+
     elif isinstance(collateral_token_contract, ContractERC20BaseClass):
         auto_deposit_erc20(
             collateral_token_contract, collateral_amount_wei, api_keys, web3
@@ -170,3 +181,49 @@ def auto_deposit_erc20(
         web3=web3,
         slippage_tolerance=slippage_tolerance,
     )
+
+
+def mint_full_set(
+    collateral_token_contract: ContractERC20BaseClass,
+    collateral_amount_wei: Wei,
+    api_keys: APIKeys,
+    web3: Web3 | None,
+) -> None:
+    router = GnosisRouter()
+    # We need to fetch the parent's market collateral token, to split it and get the collateral token
+    # of the child market.
+    seer_subgraph_handler = SeerSubgraphHandler()
+    market = seer_subgraph_handler.get_market_by_wrapped_token(
+        token=collateral_token_contract.address
+    )
+    market_collateral_token = Web3.to_checksum_address(market.collateral_token)
+
+    balance_market_collateral = ContractERC20OnGnosisChain(
+        address=market_collateral_token
+    ).balanceOf(for_address=api_keys.bet_from_address, web3=web3)
+    if balance_market_collateral < collateral_amount_wei:
+        logger.debug(
+            f"Not enough collateral token in the market. Expected {collateral_amount_wei} but got {balance_market_collateral}. Auto-depositing market collateral."
+        )
+        market_collateral_token_contract = to_gnosis_chain_contract(
+            init_collateral_token_contract(market_collateral_token, web3=web3)
+        )
+        auto_deposit_collateral_token(
+            market_collateral_token_contract, collateral_amount_wei, api_keys, web3
+        )
+
+    handle_allowance(
+        api_keys=api_keys,
+        sell_token=market_collateral_token,
+        amount_wei=collateral_amount_wei,
+        for_address=router.address,
+        web3=web3,
+    )
+
+    router.split_position(
+        api_keys=api_keys,
+        collateral_token=market_collateral_token,
+        market_id=Web3.to_checksum_address(market.id),
+        amount=collateral_amount_wei,
+        web3=web3,
+    )

{prediction_market_agent_tooling-0.67.2.dist-info → prediction_market_agent_tooling-0.67.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: prediction-market-agent-tooling
-Version: 0.67.2
+Version: 0.67.4
 Summary: Tools to benchmark, deploy and monitor prediction market agents.
 Author: Gnosis
 Requires-Python: >=3.10,<3.13