prediction-market-agent-tooling 0.62.1__tar.gz → 0.63.0__tar.gz

{prediction_market_agent_tooling-0.62.1 → prediction_market_agent_tooling-0.63.0}/PKG-INFO

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

{prediction_market_agent_tooling-0.62.1 → prediction_market_agent_tooling-0.63.0}/prediction_market_agent_tooling/deploy/betting_strategy.py

@@ -47,23 +47,39 @@ class BettingStrategy(ABC):
     @staticmethod
     def assert_buy_trade_wont_be_guaranteed_loss(
         market: AgentMarket, trades: list[Trade]
-    ) -> None:
+    ) -> list[Trade]:
+        clean_trades = []
         for trade in trades:
             if trade.trade_type == TradeType.BUY:
                 outcome_tokens_to_get = market.get_buy_token_amount(
                     trade.amount, trade.outcome
                 )
+
+                if not outcome_tokens_to_get:
+                    logger.info(
+                        f"Could not determine buy_token_amount for trade {trade}. Skipping trade."
+                    )
+                    continue
+
                 outcome_tokens_to_get_in_usd = market.get_token_in_usd(
                     outcome_tokens_to_get.as_token
                 )
+
                 if outcome_tokens_to_get_in_usd <= trade.amount:
                     raise GuaranteedLossError(
-                        f"Trade {trade=} would result in guaranteed loss by getting only {outcome_tokens_to_get=}."
+                        f"Trade {trade=} would result in guaranteed loss by getting only {outcome_tokens_to_get=}. Halting execution."
                     )
 
+            clean_trades.append(trade)
+
+        return clean_trades
+
     @staticmethod
-    def check_trades(market: AgentMarket, trades: list[Trade]) -> None:
-        BettingStrategy.assert_buy_trade_wont_be_guaranteed_loss(market, trades)
+    def filter_trades(market: AgentMarket, trades: list[Trade]) -> list[Trade]:
+        trades = BettingStrategy.assert_buy_trade_wont_be_guaranteed_loss(
+            market, trades
+        )
+        return trades
 
     def _build_rebalance_trades_from_positions(
         self,
@@ -109,7 +125,7 @@ class BettingStrategy(ABC):
         trades.sort(key=lambda t: t.trade_type == TradeType.SELL)
 
         # Run some sanity checks to not place unreasonable bets.
-        BettingStrategy.check_trades(market, trades)
+        trades = BettingStrategy.filter_trades(market, trades)
 
         return trades
 

{prediction_market_agent_tooling-0.62.1 → prediction_market_agent_tooling-0.63.0}/prediction_market_agent_tooling/markets/agent_market.py

@@ -4,6 +4,7 @@ from enum import Enum
 from eth_typing import ChecksumAddress
 from pydantic import BaseModel, field_validator, model_validator
 from pydantic_core.core_schema import FieldValidationInfo
+from web3 import Web3
 
 from prediction_market_agent_tooling.config import APIKeys
 from prediction_market_agent_tooling.gtypes import (
@@ -235,7 +236,7 @@ class AgentMarket(BaseModel):
 
     def get_buy_token_amount(
         self, bet_amount: USD | CollateralToken, direction: bool
-    ) -> OutcomeToken:
+    ) -> OutcomeToken | None:
         raise NotImplementedError("Subclasses must implement this method")
 
     def sell_tokens(self, outcome: bool, amount: USD | OutcomeToken) -> str:
@@ -293,6 +294,7 @@ class AgentMarket(BaseModel):
         traded_market: ProcessedTradedMarket | None,
         keys: APIKeys,
         agent_name: str,
+        web3: Web3 | None = None,
     ) -> None:
         """
         If market allows to upload trades somewhere, implement it in this method.

{prediction_market_agent_tooling-0.62.1 → prediction_market_agent_tooling-0.63.0}/prediction_market_agent_tooling/markets/blockchain_utils.py

@@ -22,10 +22,11 @@ def store_trades(
     traded_market: ProcessedTradedMarket | None,
     keys: APIKeys,
     agent_name: str,
+    web3: Web3 | None = None,
 ) -> None:
     if traded_market is None:
         logger.warning(f"No prediction for market {market_id}, not storing anything.")
-        return
+        return None
 
     reasoning = traded_market.answer.reasoning if traded_market.answer.reasoning else ""
 
@@ -37,9 +38,11 @@ def store_trades(
         )
         ipfs_hash_decoded = ipfscidv0_to_byte32(ipfs_hash)
 
+    # tx_hashes must be list of bytes32 (see Solidity contract).
     tx_hashes = [
         HexBytes(HexStr(i.id)) for i in traded_market.trades if i.id is not None
     ]
+
     prediction = ContractPrediction(
         publisher=keys.bet_from_address,
         ipfs_hash=ipfs_hash_decoded,
@@ -50,6 +53,7 @@ def store_trades(
         api_keys=keys,
         market_address=Web3.to_checksum_address(market_id),
         prediction=prediction,
+        web3=web3,
     )
     logger.info(
         f"Added prediction to market {market_id}. - receipt {tx_receipt['transactionHash'].hex()}."

{prediction_market_agent_tooling-0.62.1 → prediction_market_agent_tooling-0.63.0}/prediction_market_agent_tooling/markets/omen/omen.py

@@ -424,6 +424,7 @@ class OmenAgentMarket(AgentMarket):
         traded_market: ProcessedTradedMarket | None,
         keys: APIKeys,
         agent_name: str,
+        web3: Web3 | None = None,
     ) -> None:
         return store_trades(
             market_id=self.id,

{prediction_market_agent_tooling-0.62.1 → prediction_market_agent_tooling-0.63.0}/prediction_market_agent_tooling/markets/seer/data_models.py

@@ -10,16 +10,15 @@ from web3.constants import ADDRESS_ZERO
 from prediction_market_agent_tooling.config import RPCConfig
 from prediction_market_agent_tooling.gtypes import (
     ChecksumAddress,
-    CollateralToken,
     HexAddress,
     HexBytes,
     OutcomeStr,
-    Probability,
     Web3Wei,
 )
-from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.markets.data_models import Resolution
-from prediction_market_agent_tooling.tools.cow.cow_manager import CowManager
+from prediction_market_agent_tooling.markets.seer.subgraph_data_models import (
+    SeerParentMarket,
+)
 from prediction_market_agent_tooling.tools.datetime_utc import DatetimeUTC
 
 
@@ -84,10 +83,6 @@ class SeerOutcomeEnum(str, Enum):
             raise ValueError(f"Unknown outcome: {self}")
 
 
-class SeerParentMarket(BaseModel):
-    id: HexBytes
-
-
 SEER_BASE_URL = "https://app.seer.pm"
 
 
@@ -110,6 +105,7 @@ class SeerMarket(BaseModel):
     has_answers: bool | None = Field(alias="hasAnswers")
     payout_reported: bool = Field(alias="payoutReported")
     payout_numerators: list[int] = Field(alias="payoutNumerators")
+    outcomes_supply: int = Field(alias="outcomesSupply")
 
     @property
     def has_valid_answer(self) -> bool:
@@ -186,64 +182,7 @@ class SeerMarket(BaseModel):
     def created_time(self) -> DatetimeUTC:
         return DatetimeUTC.to_datetime_utc(self.block_timestamp)
 
-    @property
-    def current_p_yes(self) -> Probability:
-        price_data = {}
-        for idx in range(len(self.outcomes)):
-            wrapped_token = self.wrapped_tokens[idx]
-            price = self._get_price_for_token(
-                token=Web3.to_checksum_address(wrapped_token)
-            )
-            price_data[idx] = price
-
-        if sum(price_data.values()) == 0:
-            logger.warning(
-                f"Could not get p_yes for market {self.id.hex()}, all price quotes are 0."
-            )
-            return Probability(0)
-
-        yes_idx = self.outcome_as_enums[SeerOutcomeEnum.YES]
-        price_yes = price_data[yes_idx] / sum(price_data.values())
-        return Probability(price_yes)
-
-    def _get_price_for_token(self, token: ChecksumAddress) -> float:
-        collateral_exchange_amount = CollateralToken(1).as_wei
-        try:
-            quote = CowManager().get_quote(
-                collateral_token=self.collateral_token_contract_address_checksummed,
-                buy_token=token,
-                sell_amount=collateral_exchange_amount,
-            )
-        except Exception as e:
-            logger.warning(f"Could not get quote for {token=}, returning price 0. {e=}")
-            return 0
-
-        return collateral_exchange_amount.value / float(quote.quote.buyAmount.root)
-
     @property
     def url(self) -> str:
         chain_id = RPCConfig().chain_id
         return urljoin(SEER_BASE_URL, f"markets/{chain_id}/{self.id.hex()}")
-
-
-class SeerToken(BaseModel):
-    id: HexBytes
-    name: str
-    symbol: str
-
-
-class SeerPool(BaseModel):
-    model_config = ConfigDict(populate_by_name=True)
-    id: HexBytes
-    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-0.63.0/prediction_market_agent_tooling/markets/seer/price_manager.py

@@ -0,0 +1,117 @@
+from web3 import Web3
+
+from prediction_market_agent_tooling.gtypes import (
+    ChecksumAddress,
+    CollateralToken,
+    Probability,
+)
+from prediction_market_agent_tooling.loggers import logger
+from prediction_market_agent_tooling.markets.seer.data_models import (
+    SeerMarket,
+    SeerOutcomeEnum,
+)
+from prediction_market_agent_tooling.markets.seer.seer_subgraph_handler import (
+    SeerSubgraphHandler,
+)
+from prediction_market_agent_tooling.markets.seer.subgraph_data_models import SeerPool
+from prediction_market_agent_tooling.tools.cow.cow_order import get_quote
+from prediction_market_agent_tooling.tools.hexbytes_custom import HexBytes
+
+
+class PriceManager:
+    def __init__(self, seer_market: SeerMarket, seer_subgraph: SeerSubgraphHandler):
+        self.seer_market = seer_market
+        self.seer_subgraph = seer_subgraph
+
+    @staticmethod
+    def build(market_id: HexBytes) -> "PriceManager":
+        s = SeerSubgraphHandler()
+        market = s.get_market_by_id(market_id=market_id)
+        return PriceManager(seer_market=market, seer_subgraph=s)
+
+    def _log_track_price_normalization_diff(
+        self, old_price: float, normalized_price: float, max_price_diff: float = 0.05
+    ) -> None:
+        price_diff_pct = abs(old_price - normalized_price) / old_price
+        if price_diff_pct > max_price_diff:
+            logger.info(
+                f"{price_diff_pct=} larger than {max_price_diff=} for seer market {self.seer_market.id.hex()} "
+            )
+
+    def current_p_yes(self) -> Probability | None:
+        # Inspired by https://github.com/seer-pm/demo/blob/ca682153a6b4d4dd3dcc4ad8bdcbe32202fc8fe7/web/src/hooks/useMarketOdds.ts#L15
+        price_data: dict[int, CollateralToken | None] = {}
+        for idx, wrapped_token in enumerate(self.seer_market.wrapped_tokens):
+            price = self.get_price_for_token(
+                token=Web3.to_checksum_address(wrapped_token),
+            )
+
+            price_data[idx] = price
+
+        price_yes = price_data[self.seer_market.outcome_as_enums[SeerOutcomeEnum.YES]]
+        price_no = price_data[self.seer_market.outcome_as_enums[SeerOutcomeEnum.NO]]
+
+        # We only return a probability if we have both price_yes and price_no, since we could place bets
+        # in both sides hence we need current probabilities for both outcomes.
+        if price_yes is not None and price_no is not None:
+            normalized_price_yes = price_yes / (price_yes + price_no)
+            self._log_track_price_normalization_diff(
+                old_price=price_yes.value, normalized_price=normalized_price_yes
+            )
+            return Probability(normalized_price_yes)
+        else:
+            return None
+
+    def get_price_for_token(
+        self,
+        token: ChecksumAddress,
+        collateral_exchange_amount: CollateralToken | None = None,
+    ) -> CollateralToken | None:
+        collateral_exchange_amount = (
+            collateral_exchange_amount
+            if collateral_exchange_amount is not None
+            else CollateralToken(1)
+        )
+
+        try:
+            quote = get_quote(
+                amount_wei=collateral_exchange_amount.as_wei,
+                sell_token=self.seer_market.collateral_token_contract_address_checksummed,
+                buy_token=token,
+            )
+
+        except Exception as e:
+            logger.warning(
+                f"Could not get quote for {token=} from Cow, exception {e=}. Falling back to pools. "
+            )
+            return self.get_token_price_from_pools(token=token)
+
+        price = collateral_exchange_amount / float(quote.quote.buyAmount.root)
+        return price
+
+    @staticmethod
+    def _pool_token0_matches_token(token: ChecksumAddress, pool: SeerPool) -> bool:
+        return pool.token0.id.hex().lower() == token.lower()
+
+    def get_token_price_from_pools(
+        self,
+        token: ChecksumAddress,
+    ) -> CollateralToken | None:
+        pool = SeerSubgraphHandler().get_pool_by_token(
+            token_address=token,
+            collateral_address=self.seer_market.collateral_token_contract_address_checksummed,
+        )
+
+        if not pool:
+            logger.warning(f"Could not find a pool for {token=}")
+            return None
+
+        # The mapping below is odd but surprisingly the Algebra subgraph delivers the token1Price
+        # for the token0 and the token0Price for the token1 pool.
+        # For example, in a outcomeYES (token0)/sDAI pool (token1), token1Price is the price of outcomeYES in units of sDAI.
+        price = (
+            pool.token1Price
+            if self._pool_token0_matches_token(token=token, pool=pool)
+            else pool.token0Price
+        )
+        return price

{prediction_market_agent_tooling-0.62.1 → prediction_market_agent_tooling-0.63.0}/prediction_market_agent_tooling/markets/seer/seer.py

@@ -1,5 +1,6 @@
 import typing as t
 
+from eth_pydantic_types import HexStr
 from eth_typing import ChecksumAddress
 from web3 import Web3
 from web3.types import TxReceipt
@@ -23,30 +24,29 @@ from prediction_market_agent_tooling.markets.agent_market import (
     ProcessedTradedMarket,
     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.market_fees import MarketFees
 from prediction_market_agent_tooling.markets.omen.omen import OmenAgentMarket
 from prediction_market_agent_tooling.markets.seer.data_models import (
-    NewMarketEvent,
     SeerMarket,
     SeerOutcomeEnum,
 )
+from prediction_market_agent_tooling.markets.seer.price_manager import PriceManager
 from prediction_market_agent_tooling.markets.seer.seer_contracts import (
     SeerMarketFactory,
 )
 from prediction_market_agent_tooling.markets.seer.seer_subgraph_handler import (
     SeerSubgraphHandler,
 )
+from prediction_market_agent_tooling.markets.seer.subgraph_data_models import (
+    NewMarketEvent,
+)
 from prediction_market_agent_tooling.tools.contract import (
     ContractERC20OnGnosisChain,
     init_collateral_token_contract,
     to_gnosis_chain_contract,
 )
-from prediction_market_agent_tooling.tools.cow.cow_manager import (
-    CowManager,
-    NoLiquidityAvailableOnCowException,
-)
+from prediction_market_agent_tooling.tools.cow.cow_order import swap_tokens_waiting
 from prediction_market_agent_tooling.tools.datetime_utc import DatetimeUTC
 from prediction_market_agent_tooling.tools.tokens.auto_deposit import (
     auto_deposit_collateral_token,
@@ -93,13 +93,9 @@ class SeerAgentMarket(AgentMarket):
         traded_market: ProcessedTradedMarket | None,
         keys: APIKeys,
         agent_name: str,
+        web3: Web3 | None = None,
     ) -> None:
-        return store_trades(
-            market_id=self.id,
-            traded_market=traded_market,
-            keys=keys,
-            agent_name=agent_name,
-        )
+        pass
 
     def get_token_in_usd(self, x: CollateralToken) -> USD:
         return get_token_in_usd(x, self.collateral_token_contract_address_checksummed)
@@ -109,20 +105,22 @@ class SeerAgentMarket(AgentMarket):
 
     def get_buy_token_amount(
         self, bet_amount: USD | CollateralToken, direction: bool
-    ) -> OutcomeToken:
+    ) -> OutcomeToken | None:
         """Returns number of outcome tokens returned for a given bet expressed in collateral units."""
 
         outcome_token = self.get_wrapped_token_for_outcome(direction)
         bet_amount_in_tokens = self.get_in_token(bet_amount)
-        bet_amount_in_wei = bet_amount_in_tokens.as_wei
 
-        quote = CowManager().get_quote(
-            buy_token=outcome_token,
-            sell_amount=bet_amount_in_wei,
-            collateral_token=self.collateral_token_contract_address_checksummed,
+        p = PriceManager.build(market_id=HexBytes(HexStr(self.id)))
+        price = p.get_price_for_token(
+            token=outcome_token, collateral_exchange_amount=bet_amount_in_tokens
         )
-        sell_amount = OutcomeWei(quote.quote.buyAmount.root).as_outcome_token
-        return sell_amount
+        if not price:
+            logger.info(f"Could not get price for token {outcome_token}")
+            return None
+
+        amount_outcome_tokens = bet_amount_in_tokens / price
+        return OutcomeToken(amount_outcome_tokens)
 
     def get_outcome_str_from_bool(self, outcome: bool) -> OutcomeStr:
         outcome_translated = SeerOutcomeEnum.from_bool(outcome)
@@ -185,7 +183,17 @@ class SeerAgentMarket(AgentMarket):
         return OmenAgentMarket.verify_operational_balance(api_keys=api_keys)
 
     @staticmethod
-    def from_data_model(model: SeerMarket) -> "SeerAgentMarket":
+    def from_data_model_with_subgraph(
+        model: SeerMarket, seer_subgraph: SeerSubgraphHandler
+    ) -> t.Optional["SeerAgentMarket"]:
+        p = PriceManager(seer_market=model, seer_subgraph=seer_subgraph)
+        current_p_yes = p.current_p_yes()
+        if not current_p_yes:
+            logger.info(
+                f"p_yes for market {model.id.hex()} could not be calculated. Skipping."
+            )
+            return None
+
         return SeerAgentMarket(
             id=model.id.hex(),
             question=model.title,
@@ -201,7 +209,7 @@ class SeerAgentMarket(AgentMarket):
             outcome_token_pool=None,
             resolution=model.get_resolution_enum(),
             volume=None,
-            current_p_yes=model.current_p_yes,
+            current_p_yes=current_p_yes,
             seer_outcomes=model.outcome_as_enums,
         )
 
@@ -213,31 +221,31 @@ class SeerAgentMarket(AgentMarket):
         created_after: t.Optional[DatetimeUTC] = None,
         excluded_questions: set[str] | None = None,
     ) -> t.Sequence["SeerAgentMarket"]:
+        seer_subgraph = SeerSubgraphHandler()
+        markets = seer_subgraph.get_binary_markets(
+            limit=limit, sort_by=sort_by, filter_by=filter_by
+        )
+
+        # We exclude the None values below because `from_data_model_with_subgraph` can return None, which
+        # represents an invalid market.
         return [
-            SeerAgentMarket.from_data_model(m)
-            for m in SeerSubgraphHandler().get_binary_markets(
-                limit=limit,
-                sort_by=sort_by,
-                filter_by=filter_by,
+            market
+            for m in markets
+            if (
+                market := SeerAgentMarket.from_data_model_with_subgraph(
+                    model=m, seer_subgraph=seer_subgraph
+                )
             )
+            is not None
         ]
 
     def has_liquidity_for_outcome(self, outcome: bool) -> bool:
         outcome_token = self.get_wrapped_token_for_outcome(outcome)
-        try:
-            CowManager().get_quote(
-                collateral_token=self.collateral_token_contract_address_checksummed,
-                buy_token=outcome_token,
-                sell_amount=CollateralToken(
-                    1
-                ).as_wei,  # we take 1 as a baseline value for common trades the agents take.
-            )
-            return True
-        except NoLiquidityAvailableOnCowException:
-            logger.info(
-                f"Could not get a quote for {outcome_token=} {outcome=}, returning no liquidity"
-            )
-            return False
+        pool = SeerSubgraphHandler().get_pool_by_token(
+            token_address=outcome_token,
+            collateral_address=self.collateral_token_contract_address_checksummed,
+        )
+        return pool is not None and pool.liquidity > 0
 
     def has_liquidity(self) -> bool:
         # We conservatively define a market as having liquidity if it has liquidity for the `True` outcome token AND the `False` outcome token.
@@ -281,14 +289,54 @@ class SeerAgentMarket(AgentMarket):
             )
 
         outcome_token = self.get_wrapped_token_for_outcome(outcome)
-        # Sell using token address
-        order_metadata = CowManager().swap(
-            amount=amount_in_token,
+
+        #  Sell sDAI using token address
+        order_metadata = swap_tokens_waiting(
+            amount_wei=amount_wei,
             sell_token=collateral_contract.address,
             buy_token=outcome_token,
             api_keys=api_keys,
             web3=web3,
         )
+        logger.debug(
+            f"Purchased {outcome_token} in exchange for {collateral_contract.address}. Order details {order_metadata}"
+        )
+
+        return order_metadata.uid.root
+
+    def sell_tokens(
+        self,
+        outcome: bool,
+        amount: USD | OutcomeToken,
+        auto_withdraw: bool = True,
+        api_keys: APIKeys | None = None,
+        web3: Web3 | None = None,
+    ) -> str:
+        """
+        Sells the given number of shares for the given outcome in the given market.
+        """
+        outcome_token = self.get_wrapped_token_for_outcome(outcome)
+        api_keys = api_keys if api_keys is not None else APIKeys()
+
+        token_amount = (
+            amount.as_outcome_wei.as_wei
+            if isinstance(amount, OutcomeToken)
+            else self.get_in_token(amount).as_wei
+        )
+
+        order_metadata = swap_tokens_waiting(
+            amount_wei=token_amount,
+            sell_token=outcome_token,
+            buy_token=Web3.to_checksum_address(
+                self.collateral_token_contract_address_checksummed
+            ),
+            api_keys=api_keys,
+            web3=web3,
+        )
+
+        logger.debug(
+            f"Sold {outcome_token} in exchange for {self.collateral_token_contract_address_checksummed}. Order details {order_metadata}"
+        )
 
         return order_metadata.uid.root
 
@@ -302,7 +350,7 @@ def seer_create_market_tx(
     outcomes: t.Sequence[OutcomeStr],
     auto_deposit: bool,
     category: str,
-    min_bond_xdai: xDai,
+    min_bond: xDai,
     web3: Web3 | None = None,
 ) -> ChecksumAddress:
     web3 = web3 or SeerMarketFactory.get_web3()  # Default to Gnosis web3.
@@ -343,7 +391,7 @@ def seer_create_market_tx(
         opening_time=opening_time,
         language=language,
         category=category,
-        min_bond=min_bond_xdai,
+        min_bond=min_bond,
     )
     tx_receipt = factory_contract.create_categorical_market(
         api_keys=api_keys, params=params, web3=web3

{prediction_market_agent_tooling-0.62.1 → prediction_market_agent_tooling-0.63.0}/prediction_market_agent_tooling/markets/seer/seer_contracts.py

@@ -2,16 +2,16 @@ import os
 import typing as t
 
 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,
     OutcomeStr,
+    TxReceipt,
     xDai,
 )
-from prediction_market_agent_tooling.markets.seer.data_models import (
+from prediction_market_agent_tooling.markets.seer.subgraph_data_models import (
     CreateCategoricalMarketsParams,
 )
 from prediction_market_agent_tooling.tools.contract import (
@@ -49,7 +49,7 @@ class SeerMarketFactory(ContractOnGnosisChain):
             ],  # Following usual token names on Seer (YES,NO).
             min_bond=min_bond.as_xdai_wei.value,
             opening_time=int(opening_time.timestamp()),
-            outcomes=outcomes,
+            outcomes=list(outcomes),
             lang=language,
             category=category,
         )