prediction-market-agent-tooling 0.15.1__py3-none-any.whl → 0.17.0__py3-none-any.whl

prediction_market_agent_tooling/benchmark/agents.py

@@ -6,6 +6,7 @@ from prediction_market_agent_tooling.benchmark.utils import (
     OutcomePrediction,
     Prediction,
 )
+from prediction_market_agent_tooling.gtypes import Probability
 
 
 class AbstractBenchmarkedAgent:
@@ -86,7 +87,8 @@ class RandomAgent(AbstractBenchmarkedAgent):
         p_yes, confidence = random.random(), random.random()
         return Prediction(
             outcome_prediction=OutcomePrediction(
-                p_yes=p_yes,
+                decision=p_yes > 0.5,
+                p_yes=Probability(p_yes),
                 confidence=confidence,
                 info_utility=None,
             ),
@@ -109,7 +111,8 @@ class FixedAgent(AbstractBenchmarkedAgent):
         p_yes, confidence = 1.0 if self.fixed_answer else 0.0, 1.0
         return Prediction(
             outcome_prediction=OutcomePrediction(
-                p_yes=p_yes,
+                decision=self.fixed_answer,
+                p_yes=Probability(p_yes),
                 confidence=confidence,
                 info_utility=None,
             ),

prediction_market_agent_tooling/benchmark/utils.py

@@ -3,12 +3,11 @@ import typing as t
 
 from pydantic import BaseModel
 
+from prediction_market_agent_tooling.deploy.agent import Answer
 from prediction_market_agent_tooling.markets.data_models import Resolution
 
 
-class OutcomePrediction(BaseModel):
-    p_yes: float
-    confidence: float
+class OutcomePrediction(Answer):
     info_utility: t.Optional[float]
 
     @property

prediction_market_agent_tooling/deploy/agent.py

@@ -6,6 +6,8 @@ import typing as t
 from datetime import datetime
 
 from loguru import logger
+from pydantic import BaseModel, BeforeValidator
+from typing_extensions import Annotated
 
 from prediction_market_agent_tooling.config import APIKeys, PrivateCredentials
 from prediction_market_agent_tooling.deploy.constants import (
@@ -21,6 +23,7 @@ from prediction_market_agent_tooling.deploy.gcp.utils import (
     gcp_function_is_active,
     gcp_resolve_api_keys_secrets,
 )
+from prediction_market_agent_tooling.gtypes import Probability
 from prediction_market_agent_tooling.markets.agent_market import (
     AgentMarket,
     FilterBy,
@@ -39,6 +42,40 @@ from prediction_market_agent_tooling.tools.utils import DatetimeWithTimezone, ut
 MAX_AVAILABLE_MARKETS = 20
 
 
+def to_boolean_outcome(value: str | bool) -> bool:
+    if isinstance(value, bool):
+        return value
+
+    elif isinstance(value, str):
+        value = value.lower().strip()
+
+        if value in {"true", "yes", "y", "1"}:
+            return True
+
+        elif value in {"false", "no", "n", "0"}:
+            return False
+
+        else:
+            raise ValueError(f"Expected a boolean string, but got {value}")
+
+    else:
+        raise ValueError(f"Expected a boolean or a string, but got {value}")
+
+
+Decision = Annotated[bool, BeforeValidator(to_boolean_outcome)]
+
+
+class Answer(BaseModel):
+    decision: Decision  # Warning: p_yes > 0.5 doesn't necessarily mean decision is True! For example, if our p_yes is 55%, but market's p_yes is 80%, then it might be profitable to bet on False.
+    p_yes: Probability
+    confidence: float
+    reasoning: str | None = None
+
+    @property
+    def p_no(self) -> Probability:
+        return Probability(1 - self.p_yes)
+
+
 class DeployableAgent:
     def __init__(self) -> None:
         self.load()
@@ -58,7 +95,7 @@ class DeployableAgent:
         """
         return markets[:1]
 
-    def answer_binary_market(self, market: AgentMarket) -> bool | None:
+    def answer_binary_market(self, market: AgentMarket) -> Answer | None:
         """
         Answer the binary market. This method must be implemented by the subclass.
         """
@@ -157,7 +194,7 @@ def {entrypoint_function_name}(request) -> str:
         if cron_schedule:
             schedule_deployed_gcp_function(fname, cron_schedule=cron_schedule)
 
-    def calculate_bet_amount(self, answer: bool, market: AgentMarket) -> BetAmount:
+    def calculate_bet_amount(self, answer: Answer, market: AgentMarket) -> BetAmount:
         """
         Calculate the bet amount. By default, it returns the minimum bet amount.
         """
@@ -205,7 +242,7 @@ def {entrypoint_function_name}(request) -> str:
                 )
                 market.place_bet(
                     amount=amount,
-                    outcome=result,
+                    outcome=result.decision,
                 )
 
     def after(self, market_type: MarketType) -> None:

prediction_market_agent_tooling/deploy/agent_example.py

@@ -1,7 +1,11 @@
 import random
 import typing as t
 
-from prediction_market_agent_tooling.deploy.agent import DeployableAgent
+from prediction_market_agent_tooling.deploy.agent import (
+    Answer,
+    DeployableAgent,
+    Probability,
+)
 from prediction_market_agent_tooling.markets.agent_market import AgentMarket
 
 
@@ -9,10 +13,16 @@ class DeployableCoinFlipAgent(DeployableAgent):
     def pick_markets(self, markets: t.Sequence[AgentMarket]) -> t.Sequence[AgentMarket]:
         return random.sample(markets, 1)
 
-    def answer_binary_market(self, market: AgentMarket) -> bool | None:
-        return random.choice([True, False])
+    def answer_binary_market(self, market: AgentMarket) -> Answer | None:
+        decision = random.choice([True, False])
+        return Answer(
+            decision=decision,
+            p_yes=Probability(float(decision)),
+            confidence=0.5,
+            reasoning="I flipped a coin to decide.",
+        )
 
 
 class DeployableAlwaysRaiseAgent(DeployableAgent):
-    def answer_binary_market(self, market: AgentMarket) -> bool | None:
+    def answer_binary_market(self, market: AgentMarket) -> Answer | None:
         raise RuntimeError("I always raise!")

prediction_market_agent_tooling/markets/omen/{omen_resolve_replicated.py → omen_resolving.py}

@@ -1,7 +1,4 @@
-from datetime import timedelta
-
 from loguru import logger
-from pydantic import BaseModel
 from web3 import Web3
 
 from prediction_market_agent_tooling.config import PrivateCredentials
@@ -34,81 +31,10 @@ from prediction_market_agent_tooling.markets.omen.omen_subgraph_handler import (
 from prediction_market_agent_tooling.markets.polymarket.utils import (
     find_resolution_on_polymarket,
 )
-from prediction_market_agent_tooling.tools.balances import get_balances
-from prediction_market_agent_tooling.tools.utils import utcnow
 from prediction_market_agent_tooling.tools.web3_utils import ZERO_BYTES, xdai_to_wei
 
 
-class FinalizeAndResolveResult(BaseModel):
-    finalized: list[HexAddress]
-    resolved: list[HexAddress]
-    claimed_question_ids: list[HexBytes]
-
-
-def omen_finalize_and_resolve_and_claim_back_all_markets_based_on_others_tx(
-    private_credentials: PrivateCredentials,
-) -> FinalizeAndResolveResult:
-    public_key = private_credentials.public_key
-    balances_start = get_balances(public_key)
-    logger.info(f"{balances_start=}")
-
-    # Just to be friendly with timezones.
-    before = utcnow() - timedelta(hours=8)
-
-    # Fetch markets created by us that are already open, but no answer was submitted yet.
-    created_opened_markets = OmenSubgraphHandler().get_omen_binary_markets(
-        limit=None,
-        creator=public_key,
-        opened_before=before,
-        finalized=False,
-    )
-    # Finalize them (set answer on Realitio).
-    finalized_markets = finalize_markets(
-        private_credentials,
-        created_opened_markets,
-    )
-    balances_after_finalization = get_balances(public_key)
-    logger.info(f"{balances_after_finalization=}")
-
-    # Fetch markets created by us that are already open, and we already submitted an answer more than a day ago, but they aren't resolved yet.
-    created_finalized_markets = OmenSubgraphHandler().get_omen_binary_markets(
-        limit=None,
-        creator=public_key,
-        finalized_before=before - timedelta(hours=24),
-        resolved=False,
-    )
-    # Resolve them (resolve them on Oracle).
-    resolved_markets = resolve_markets(
-        private_credentials,
-        created_finalized_markets,
-    )
-    balances_after_resolution = get_balances(public_key)
-    logger.info(f"{balances_after_resolution=}")
-
-    # Fetch questions that are already finalised (last answer is older than 24 hours), but we didn't claim the bonded xDai yet.
-    created_not_claimed_questions: list[
-        RealityQuestion
-    ] = OmenSubgraphHandler().get_questions(
-        user=public_key,
-        claimed=False,
-        current_answer_before=before - timedelta(hours=24),
-    )
-    claimed_question_ids = claim_bonds_on_realitio_quetions(
-        private_credentials,
-        created_not_claimed_questions,
-        auto_withdraw=True,
-    )
-    balances_after_claiming = get_balances(public_key)
-    logger.info(f"{balances_after_claiming=}")
-
-    return FinalizeAndResolveResult(
-        finalized=finalized_markets,
-        resolved=resolved_markets,
-        claimed_question_ids=claimed_question_ids,
-    )
-
-
-def claim_bonds_on_realitio_quetions(
+def claim_bonds_on_realitio_questions(
     private_credentials: PrivateCredentials,
     questions: list[RealityQuestion],
     auto_withdraw: bool,
@@ -194,18 +120,17 @@ def claim_bonds_on_realitio_question(
 
 def finalize_markets(
     private_credentials: PrivateCredentials,
-    markets: list[OmenMarket],
+    markets_with_resolutions: list[tuple[OmenMarket, Resolution | None]],
 ) -> list[HexAddress]:
     finalized_markets: list[HexAddress] = []
 
-    for idx, market in enumerate(markets):
+    for idx, (market, resolution) in enumerate(markets_with_resolutions):
         logger.info(
-            f"[{idx+1} / {len(markets)}] Looking into {market.url=} {market.question_title=}"
+            f"[{idx+1} / {len(markets_with_resolutions)}] Looking into {market.url=} {market.question_title=}"
         )
-        resolution = find_resolution_on_other_markets(market)
 
         if resolution is None:
-            logger.error(f"No resolution found for {market.url=}")
+            logger.error(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-0.15.1.dist-info → prediction_market_agent_tooling-0.17.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: prediction-market-agent-tooling
-Version: 0.15.1
+Version: 0.17.0
 Summary: Tools to benchmark, deploy and monitor prediction market agents.
 Author: Gnosis
 Requires-Python: >=3.10,<3.12

{prediction_market_agent_tooling-0.15.1.dist-info → prediction_market_agent_tooling-0.17.0.dist-info}/RECORD

@@ -8,12 +8,12 @@ prediction_market_agent_tooling/abis/omen_oracle.abi.json,sha256=YPZ-FLvd4PA9pYd
 prediction_market_agent_tooling/abis/omen_realitio.abi.json,sha256=7HmFkBF_rq83UTaH2kRRsEfc_WZuf4n-qvkB4nhvweo,15953
 prediction_market_agent_tooling/abis/wxdai.abi.json,sha256=m3qC06Yug-pToI0lSFe1f8e6gKMIulnV3MA2K0X51hI,6055
 prediction_market_agent_tooling/benchmark/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-prediction_market_agent_tooling/benchmark/agents.py,sha256=HtZGjY0En7lmUaLyynZSNO_YjsCg-hlRi6YQ4ZGQyHc,3829
+prediction_market_agent_tooling/benchmark/agents.py,sha256=HPIFJvackW110ch3UkktbxhU48gMRVo4gQse84Klhdc,4000
 prediction_market_agent_tooling/benchmark/benchmark.py,sha256=xiHKzZx5GHSsDerFHMZ9j_LXAXnSaITSvv67iPe3MEU,21095
-prediction_market_agent_tooling/benchmark/utils.py,sha256=mRHhkS-_TrDSh4uyz-d36bKlJdwDk1w6gyfzXUc2Mrs,2875
+prediction_market_agent_tooling/benchmark/utils.py,sha256=iS1BzyXcCMfMm1Rx--1QCH0pHvBTblTndcDQFbTUJ2s,2897
 prediction_market_agent_tooling/config.py,sha256=Cvl9RWlOEPRzdSE7-ChTyKSMNTgNoOYmtJ0lT5yDqpE,3570
-prediction_market_agent_tooling/deploy/agent.py,sha256=ju-BDe8Ek1mTLWMoIyp_LLcNt2KhxgITa0O8OtgW_ko,7788
-prediction_market_agent_tooling/deploy/agent_example.py,sha256=vwswPCOutCG9vIqJT5lBcI1FZy3QRkNyVbNIJdn6wvk,652
+prediction_market_agent_tooling/deploy/agent.py,sha256=hpk2VvRBHU1d7_tcYaZg5V3bvhehl7ZgUjn3jc6iAMY,8916
+prediction_market_agent_tooling/deploy/agent_example.py,sha256=KaTJm43cwbBZR2BmTEyB1ohChAqwYlBUqaaVumsWQe4,891
 prediction_market_agent_tooling/deploy/constants.py,sha256=M5ty8URipYMGe_G-RzxRydK3AFL6CyvmqCraJUrLBnE,82
 prediction_market_agent_tooling/deploy/gcp/deploy.py,sha256=CYUgnfy-9XVk04kkxA_5yp0GE9Mw5caYqlFUZQ2j3ks,3739
 prediction_market_agent_tooling/deploy/gcp/kubernetes_models.py,sha256=qYIHRxQLac3yxtZ8ChikiPG9O1aUQucHW0muTSm1nto,2627
@@ -32,8 +32,7 @@ prediction_market_agent_tooling/markets/omen/__init__.py,sha256=47DEQpj8HBSa-_TI
 prediction_market_agent_tooling/markets/omen/data_models.py,sha256=g6A_DQ54m-_3XQO02AM4NliDycsgYvg8hgpt8Dri5cg,14111
 prediction_market_agent_tooling/markets/omen/omen.py,sha256=aZhz2dRFYuAP2h1TlrPWN4lIuOrSvvCjXV-3WcP3TG4,31392
 prediction_market_agent_tooling/markets/omen/omen_contracts.py,sha256=vblZAS_aWTSB6I5LDx_E7hg5gyvocs1I9qxSfxM8YfM,19733
-prediction_market_agent_tooling/markets/omen/omen_replicate.py,sha256=1Yp8vpuZS15kIMPKqMxH0vrvXOsStI4KVA2DrS4V134,7409
-prediction_market_agent_tooling/markets/omen/omen_resolve_replicated.py,sha256=v6fRGv3Loy5PARoRyyAiCNY2TvKGE-Jxr27-1i-D40A,11356
+prediction_market_agent_tooling/markets/omen/omen_resolving.py,sha256=OXgcdXN4mFw9kjhtcTWZ7O3RdHYJdq2aAA52dzj-MqQ,8726
 prediction_market_agent_tooling/markets/omen/omen_subgraph_handler.py,sha256=F2JyAYqCR4REOnFB2cngbngh7ib7SMt0VtFw7mGt2Yc,22266
 prediction_market_agent_tooling/markets/polymarket/api.py,sha256=p1JkqL9kF8C04qbmqFzF0hgtzD5kN3yup2hYOjxazQ4,4188
 prediction_market_agent_tooling/markets/polymarket/data_models.py,sha256=srTl8-0FM76AGLRDWzjLpf46ikWloaBCgkn0XqZoKCI,4248
@@ -64,8 +63,8 @@ prediction_market_agent_tooling/tools/safe.py,sha256=gNgcY6ugckx3DbupR8VBezDgh1d
 prediction_market_agent_tooling/tools/singleton.py,sha256=CiIELUiI-OeS7U7eeHEt0rnVhtQGzwoUdAgn_7u_GBM,729
 prediction_market_agent_tooling/tools/utils.py,sha256=6MRfLr5xGPEQGobLz_eCsE_p-XaAeOCcmygwgNCIvqE,5044
 prediction_market_agent_tooling/tools/web3_utils.py,sha256=tl_uN-SpKK4nXpqlSozefzMXpbAe9rFzaCB9IQ0QJxY,8335
-prediction_market_agent_tooling-0.15.1.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
-prediction_market_agent_tooling-0.15.1.dist-info/METADATA,sha256=3PCBmKISvfL0pfNUibhzvXD59uu4YEv4pxH536xdviw,5468
-prediction_market_agent_tooling-0.15.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-prediction_market_agent_tooling-0.15.1.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
-prediction_market_agent_tooling-0.15.1.dist-info/RECORD,,
+prediction_market_agent_tooling-0.17.0.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
+prediction_market_agent_tooling-0.17.0.dist-info/METADATA,sha256=Z-mAb4_umw_MR5dyNTEybglqltb3DTvvmOufBifARTk,5468
+prediction_market_agent_tooling-0.17.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+prediction_market_agent_tooling-0.17.0.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
+prediction_market_agent_tooling-0.17.0.dist-info/RECORD,,

prediction_market_agent_tooling/markets/omen/omen_replicate.py

@@ -1,184 +0,0 @@
-from datetime import datetime, timedelta
-
-from loguru import logger
-
-from prediction_market_agent_tooling.config import PrivateCredentials
-from prediction_market_agent_tooling.gtypes import ChecksumAddress, wei_type, xDai
-from prediction_market_agent_tooling.markets.agent_market import FilterBy, SortBy
-from prediction_market_agent_tooling.markets.categorize import infer_category
-from prediction_market_agent_tooling.markets.markets import (
-    MarketType,
-    get_binary_markets,
-)
-from prediction_market_agent_tooling.markets.omen.data_models import (
-    OMEN_FALSE_OUTCOME,
-    OMEN_TRUE_OUTCOME,
-)
-from prediction_market_agent_tooling.markets.omen.omen import (
-    OMEN_DEFAULT_MARKET_FEE,
-    OmenAgentMarket,
-    omen_create_market_tx,
-    omen_remove_fund_market_tx,
-)
-from prediction_market_agent_tooling.markets.omen.omen_subgraph_handler import (
-    OmenSubgraphHandler,
-)
-from prediction_market_agent_tooling.tools.is_predictable import is_predictable_binary
-from prediction_market_agent_tooling.tools.utils import utcnow
-
-# According to Omen's recommendation, closing time of the market should be at least 6 days after the outcome is known.
-# That is because at the closing time, the question will open on Realitio, and we don't want it to be resolved as unknown/invalid.
-# All replicated markets that close at N, needs to have closing time on Realition N + `EXTEND_CLOSING_TIME_DELTA`.
-EXTEND_CLOSING_TIME_DELTA = timedelta(days=6)
-
-
-def omen_replicate_from_tx(
-    private_credentials: PrivateCredentials,
-    market_type: MarketType,
-    n_to_replicate: int,
-    initial_funds: xDai,
-    close_time_before: datetime | None = None,
-    auto_deposit: bool = False,
-) -> list[ChecksumAddress]:
-    from_address = private_credentials.public_key
-    already_created_markets = OmenSubgraphHandler().get_omen_binary_markets(
-        limit=None,
-        creator=from_address,
-    )
-
-    markets = get_binary_markets(
-        # Polymarket is slow to get, so take only 10 candidates for him.
-        10 if market_type == MarketType.POLYMARKET else 100,
-        market_type,
-        filter_by=FilterBy.OPEN,
-        sort_by=SortBy.NONE,
-        excluded_questions=set(m.question_title for m in already_created_markets),
-    )
-    markets_sorted = sorted(
-        markets,
-        key=lambda m: m.volume or 0,
-        reverse=True,
-    )
-    markets_to_replicate = [
-        m
-        for m in markets_sorted
-        if close_time_before is None
-        or (m.close_time is not None and m.close_time <= close_time_before)
-    ]
-    if not markets_to_replicate:
-        logger.info(f"No markets found for {market_type}")
-        return []
-
-    logger.info(f"Found {len(markets_to_replicate)} markets to replicate.")
-
-    # Get a set of possible categories from existing markets (but created by anyone, not just your agent)
-    existing_categories = set(
-        m.category
-        for m in OmenSubgraphHandler().get_omen_binary_markets_simple(
-            limit=1000,
-            sort_by=SortBy.NEWEST,
-            filter_by=FilterBy.NONE,
-        )
-    )
-
-    created_addresses: list[ChecksumAddress] = []
-
-    for market in markets_to_replicate:
-        if market.close_time is None:
-            logger.info(
-                f"Skipping `{market.question}` because it's missing the closing time."
-            )
-            continue
-
-        safe_closing_time = market.close_time + EXTEND_CLOSING_TIME_DELTA
-        # Force at least 48 hours of time where the resolution is unknown.
-        soonest_allowed_resolution_known_time = utcnow() + timedelta(hours=48)
-        if market.close_time <= soonest_allowed_resolution_known_time:
-            logger.info(
-                f"Skipping `{market.question}` because it closes sooner than {soonest_allowed_resolution_known_time}."
-            )
-            continue
-
-        # Do as the last step, becuase it calls OpenAI (costly & slow).
-        if not is_predictable_binary(market.question):
-            logger.info(
-                f"Skipping `{market.question}` because it seems to not be predictable."
-            )
-            continue
-
-        category = infer_category(market.question, existing_categories)
-        # Realitio will allow new categories or misformated categories, so double check that the LLM got it right.
-        if category not in existing_categories:
-            logger.info(
-                f"Error: LLM went rouge. Skipping `{market.question}` because the category `{category}` is not in the existing categories {existing_categories}."
-            )
-            continue
-
-        market_address = omen_create_market_tx(
-            private_credentials=private_credentials,
-            initial_funds=initial_funds,
-            fee=OMEN_DEFAULT_MARKET_FEE,
-            question=market.question,
-            closing_time=safe_closing_time,
-            category=category,
-            language="en",
-            outcomes=[OMEN_TRUE_OUTCOME, OMEN_FALSE_OUTCOME],
-            auto_deposit=auto_deposit,
-        )
-        created_addresses.append(market_address)
-        logger.info(
-            f"Created `https://aiomen.eth.limo/#/{market_address}` for `{market.question}` in category {category} out of {market.url}."
-        )
-
-        if len(created_addresses) >= n_to_replicate:
-            logger.info(
-                f"Replicated {len(created_addresses)} from {market_type}, breaking."
-            )
-            break
-
-    return created_addresses
-
-
-def omen_unfund_replicated_known_markets_tx(
-    private_credentials: PrivateCredentials,
-    saturation_above_threshold: float | None = None,
-) -> None:
-    from_address = private_credentials.public_key
-
-    now = utcnow()
-    # We want to unfund markets ~1 day before the resolution should be known.
-    # That is, if the original market would be closing now, but we added `EXTEND_CLOSING_TIME_DELTA` to it,
-    # we want to unfund any market that closes sooner than NOW + `EXTEND_CLOSING_TIME_DELTA` - 1 day.
-    opened_before = now + EXTEND_CLOSING_TIME_DELTA - timedelta(days=1)
-
-    # Fetch markets that we created, are soon to be known,
-    # and still have liquidity in them (we didn't withdraw it yet).
-    markets = OmenSubgraphHandler().get_omen_binary_markets(
-        limit=None,
-        creator=from_address,
-        opened_before=opened_before,
-        liquidity_bigger_than=wei_type(0),
-    )
-
-    for idx, market in enumerate(markets):
-        # Optionally, if `saturation_above_threshold` is provided, skip markets that are not saturated to leave some free money motivation for agents.
-        if (
-            saturation_above_threshold is not None
-            and not market.is_resolved
-            and not (
-                market.current_p_yes > saturation_above_threshold
-                or market.current_p_no > saturation_above_threshold
-            )
-        ):
-            logger.info(
-                f"[{idx+1}/{len(markets)}] Skipping unfunding of `{market.liquidityParameter=} {market.question=}  {market.url=}`, because it's not saturated yet, `{market.current_p_yes=}`."
-            )
-            continue
-        logger.info(
-            f"[{idx+1}/{len(markets)}] Unfunding market `{market.liquidityParameter=} {market.question=} {market.url=}`."
-        )
-        omen_remove_fund_market_tx(
-            private_credentials=private_credentials,
-            market=OmenAgentMarket.from_data_model(market),
-            shares=None,
-        )