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

prediction_market_agent_tooling/markets/seer/data_models.py

@@ -48,10 +48,14 @@ class CreateCategoricalMarketsParams(BaseModel):
 SEER_BASE_URL = "https://app.seer.pm"
 
 
-def seer_normalize_wei(value: int | None) -> int | None:
+def seer_normalize_wei(value: int | dict[str, t.Any] | None) -> int | None:
     # See https://github.com/seer-pm/demo/blob/main/web/netlify/edge-functions/utils/common.ts#L22
     if value is None:
         return value
+    elif isinstance(value, dict):
+        if value.get("value") is None:
+            raise ValueError(f"Expected a dictionary with a value key, but got {value}")
+        value = int(value["value"])
     is_in_wei = value > 1e10
     return value if is_in_wei else value * 10**18
 
@@ -59,6 +63,21 @@ def seer_normalize_wei(value: int | None) -> int | None:
 SeerNormalizedWei = Annotated[Wei | None, BeforeValidator(seer_normalize_wei)]
 
 
+class MarketId(BaseModel):
+    id: HexBytes
+
+
+class SeerQuestion(BaseModel):
+    id: str
+    best_answer: HexBytes
+    finalize_ts: int
+
+
+class SeerMarketQuestions(BaseModel):
+    question: SeerQuestion
+    market: MarketId
+
+
 class SeerMarket(BaseModel):
     model_config = ConfigDict(populate_by_name=True)
 
@@ -71,6 +90,7 @@ class SeerMarket(BaseModel):
         alias="parentOutcome", description="It comes as 0 from non-conditioned markets."
     )
     parent_market: t.Optional["SeerMarket"] = Field(alias="parentMarket", default=None)
+    template_id: int = Field(alias="templateId")
     collateral_token: HexAddress = Field(alias="collateralToken")
     condition_id: HexBytes = Field(alias="conditionId")
     opening_ts: int = Field(alias="openingTs")
@@ -143,6 +163,10 @@ class SeerMarket(BaseModel):
         return urljoin(SEER_BASE_URL, f"markets/{chain_id}/{self.id.hex()}")
 
 
+class SeerMarketWithQuestions(SeerMarket):
+    questions: list[SeerMarketQuestions]
+
+
 class RedeemParams(BaseModel):
     model_config = ConfigDict(populate_by_name=True)
     market: ChecksumAddress

prediction_market_agent_tooling/markets/seer/seer.py

@@ -23,8 +23,8 @@ from prediction_market_agent_tooling.gtypes import (
 from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.markets.agent_market import (
     AgentMarket,
+    ConditionalFilterType,
     FilterBy,
-    MarketFees,
     ParentMarket,
     ProcessedMarket,
     ProcessedTradedMarket,
@@ -32,7 +32,10 @@ from prediction_market_agent_tooling.markets.agent_market import (
     SortBy,
 )
 from prediction_market_agent_tooling.markets.blockchain_utils import store_trades
-from prediction_market_agent_tooling.markets.data_models import ExistingPosition
+from prediction_market_agent_tooling.markets.data_models import (
+    ExistingPosition,
+    Resolution,
+)
 from prediction_market_agent_tooling.markets.market_fees import MarketFees
 from prediction_market_agent_tooling.markets.omen.omen import OmenAgentMarket
 from prediction_market_agent_tooling.markets.omen.omen_constants import (
@@ -44,6 +47,7 @@ from prediction_market_agent_tooling.markets.omen.omen_contracts import (
 from prediction_market_agent_tooling.markets.seer.data_models import (
     RedeemParams,
     SeerMarket,
+    SeerMarketWithQuestions,
 )
 from prediction_market_agent_tooling.markets.seer.exceptions import (
     PriceCalculationError,
@@ -54,7 +58,9 @@ from prediction_market_agent_tooling.markets.seer.seer_contracts import (
     SeerMarketFactory,
 )
 from prediction_market_agent_tooling.markets.seer.seer_subgraph_handler import (
+    SeerQuestionsCache,
     SeerSubgraphHandler,
+    TemplateId,
 )
 from prediction_market_agent_tooling.markets.seer.subgraph_data_models import (
     NewMarketEvent,
@@ -257,7 +263,7 @@ class SeerAgentMarket(AgentMarket):
     @staticmethod
     def _filter_markets_contained_in_trades(
         api_keys: APIKeys,
-        markets: list[SeerMarket],
+        markets: t.Sequence[SeerMarket],
     ) -> list[SeerMarket]:
         """
         We filter the markets using previous trades by the user so that we don't have to process all Seer markets.
@@ -267,7 +273,7 @@ class SeerAgentMarket(AgentMarket):
         traded_tokens = {t.buyToken for t in trades_by_user}.union(
             [t.sellToken for t in trades_by_user]
         )
-        filtered_markets = []
+        filtered_markets: list[SeerMarket] = []
         for market in markets:
             if any(
                 [
@@ -338,9 +344,64 @@ class SeerAgentMarket(AgentMarket):
         return OmenAgentMarket.verify_operational_balance(api_keys=api_keys)
 
     @staticmethod
-    def from_data_model_with_subgraph(
+    def build_resolution(
+        model: SeerMarketWithQuestions,
+    ) -> Resolution | None:
+        if model.questions[0].question.finalize_ts == 0:
+            # resolution not yet finalized
+            return None
+
+        if model.template_id != TemplateId.CATEGORICAL:
+            logger.warning("Resolution can only be built for categorical markets.")
+            # Future note - for scalar markets, simply fetch best_answer and convert
+            # from hex into int and divide by 1e18 (because Wei).
+            return None
+
+        if len(model.questions) != 1:
+            raise ValueError("Seer categorical markets must have 1 question.")
+
+        question = model.questions[0]
+        outcome = model.outcomes[int(question.question.best_answer.hex(), 16)]
+        return Resolution(outcome=outcome, invalid=False)
+
+    @staticmethod
+    def convert_seer_market_into_market_with_questions(
+        seer_market: SeerMarket, seer_subgraph: SeerSubgraphHandler
+    ) -> "SeerMarketWithQuestions":
+        q = SeerQuestionsCache(seer_subgraph_handler=seer_subgraph)
+        q.fetch_questions([seer_market.id])
+        questions = q.market_id_to_questions[seer_market.id]
+        return SeerMarketWithQuestions(**seer_market.model_dump(), questions=questions)
+
+    @staticmethod
+    def get_parent(
         model: SeerMarket,
         seer_subgraph: SeerSubgraphHandler,
+    ) -> t.Optional["ParentMarket"]:
+        if not model.parent_market:
+            return None
+
+        # turn into a market with questions
+        parent_market_with_questions = (
+            SeerAgentMarket.convert_seer_market_into_market_with_questions(
+                model.parent_market, seer_subgraph=seer_subgraph
+            )
+        )
+
+        market_with_questions = check_not_none(
+            SeerAgentMarket.from_data_model_with_subgraph(
+                parent_market_with_questions, seer_subgraph, False
+            )
+        )
+
+        return ParentMarket(
+            market=market_with_questions, parent_outcome=model.parent_outcome
+        )
+
+    @staticmethod
+    def from_data_model_with_subgraph(
+        model: SeerMarketWithQuestions,
+        seer_subgraph: SeerSubgraphHandler,
         must_have_prices: bool,
     ) -> t.Optional["SeerAgentMarket"]:
         price_manager = PriceManager(seer_market=model, seer_subgraph=seer_subgraph)
@@ -356,6 +417,10 @@ class SeerAgentMarket(AgentMarket):
                 # Price calculation failed, so don't return the market
                 return None
 
+        resolution = SeerAgentMarket.build_resolution(model=model)
+
+        parent = SeerAgentMarket.get_parent(model=model, seer_subgraph=seer_subgraph)
+
         market = SeerAgentMarket(
             id=model.id.hex(),
             question=model.title,
@@ -370,27 +435,12 @@ class SeerAgentMarket(AgentMarket):
             fees=MarketFees.get_zero_fees(),
             outcome_token_pool=None,
             outcomes_supply=model.outcomes_supply,
-            resolution=None,
+            resolution=resolution,
             volume=None,
             probabilities=probability_map,
             upper_bound=model.upper_bound,
             lower_bound=model.lower_bound,
-            parent=(
-                ParentMarket(
-                    market=(
-                        check_not_none(
-                            SeerAgentMarket.from_data_model_with_subgraph(
-                                model.parent_market,
-                                seer_subgraph,
-                                False,
-                            )
-                        )
-                    ),
-                    parent_outcome=model.parent_outcome,
-                )
-                if model.parent_market
-                else None
-            ),
+            parent=parent,
         )
 
         return market
@@ -403,7 +453,7 @@ class SeerAgentMarket(AgentMarket):
         created_after: t.Optional[DatetimeUTC] = None,
         excluded_questions: set[str] | None = None,
         question_type: QuestionType = QuestionType.ALL,
-        include_conditional_markets: bool = False,
+        conditional_filter_type: ConditionalFilterType = ConditionalFilterType.ONLY_NOT_CONDITIONAL,
     ) -> t.Sequence["SeerAgentMarket"]:
         seer_subgraph = SeerSubgraphHandler()
 
@@ -412,7 +462,7 @@ class SeerAgentMarket(AgentMarket):
             sort_by=sort_by,
             filter_by=filter_by,
             question_type=question_type,
-            include_conditional_markets=include_conditional_markets,
+            conditional_filter_type=conditional_filter_type,
         )
 
         # We exclude the None values below because `from_data_model_with_subgraph` can return None, which

prediction_market_agent_tooling/markets/seer/seer_contracts.py

@@ -9,6 +9,7 @@ from prediction_market_agent_tooling.gtypes import (
     ChecksumAddress,
     OutcomeStr,
     TxReceipt,
+    Wei,
     xDai,
 )
 from prediction_market_agent_tooling.markets.seer.data_models import (
@@ -115,6 +116,23 @@ class GnosisRouter(ContractOnGnosisChain):
         )
         return receipt_tx
 
+    def split_position(
+        self,
+        api_keys: APIKeys,
+        collateral_token: ChecksumAddress,
+        market_id: ChecksumAddress,
+        amount: Wei,
+        web3: Web3 | None = None,
+    ) -> TxReceipt:
+        """Splits collateral token into full set of outcome tokens."""
+        receipt_tx = self.send(
+            api_keys=api_keys,
+            function_name="splitPosition",
+            function_params=[collateral_token, market_id, amount],
+            web3=web3,
+        )
+        return receipt_tx
+
 
 class SwaprRouterContract(ContractOnGnosisChain):
     # File content taken from https://github.com/protofire/omen-exchange/blob/master/app/src/abi/marketMaker.json.

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/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/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,