137 arbitrage agent

prediction_market_agent/agents/arbitrage_agent/data_models.py

@@ -0,0 +1,73 @@
+import typing as t
+
+from prediction_market_agent_tooling.markets.agent_market import AgentMarket
+from pydantic import BaseModel, computed_field
+
+
+class Correlation(BaseModel):
+    near_perfect_correlation: bool
+    reasoning: str
+
+
+class CorrelatedMarketPair(BaseModel):
+    main_market: AgentMarket
+    related_market: AgentMarket
+
+    def __repr__(self) -> str:
+        return f"main_market_question {self.main_market.question=} related_market_question {self.related_market.question=}"
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def potential_profit_per_bet_unit(self) -> float:
+        """
+        Calculate potential profit per bet unit based on high positive market correlation.
+        For positively correlated markets: Bet YES/NO or NO/YES.
+        """
+        # Smaller correlations will be handled in a future ticket
+        # https://github.com/gnosis/prediction-market-agent/issues/508
+        # Negative correlations are not yet supported by the current LLM prompt, hence not handling those for now.
+        p_yes = min(self.main_market.current_p_yes, self.related_market.current_p_yes)
+        p_no = min(self.main_market.current_p_no, self.related_market.current_p_no)
+        total_probability = p_yes + p_no
+
+        # Ensure total_probability is non-zero to avoid division errors
+        if total_probability > 0:
+            return (1.0 / total_probability) - 1.0
+        else:
+            return 0  # No arbitrage possible if the sum of probabilities is zero
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def market_to_bet_yes(self) -> AgentMarket:
+        return (
+            self.main_market
+            if self.main_market.current_p_yes <= self.related_market.current_p_yes
+            else self.related_market
+        )
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def market_to_bet_no(self) -> AgentMarket:
+        return (
+            self.main_market
+            if self.main_market.current_p_yes > self.related_market.current_p_yes
+            else self.related_market
+        )
+
+    def split_bet_amount_between_yes_and_no(
+        self, total_bet_amount: float
+    ) -> t.Tuple[float, float]:
+        """Splits total bet amount following equations below:
+        A1/p1 = A2/p2 (same profit regardless of outcome resolution)
+        A1 + A2 = total bet amount
+        """
+        amount_to_bet_yes = (
+            total_bet_amount
+            * self.market_to_bet_yes.current_p_yes
+            / (
+                self.market_to_bet_yes.current_p_yes
+                + self.market_to_bet_no.current_p_no
+            )
+        )
+        amount_to_bet_no = total_bet_amount - amount_to_bet_yes
+        return amount_to_bet_yes, amount_to_bet_no

prediction_market_agent/agents/arbitrage_agent/deploy.py

@@ -0,0 +1,186 @@
+import typing as t
+
+from langchain_core.output_parsers import PydanticOutputParser
+from langchain_core.prompts import PromptTemplate
+from langchain_core.runnables import RunnableSerializable
+from langchain_openai import ChatOpenAI
+from prediction_market_agent_tooling.deploy.agent import (
+    MAX_AVAILABLE_MARKETS,
+    DeployableTraderAgent,
+)
+from prediction_market_agent_tooling.gtypes import Probability
+from prediction_market_agent_tooling.loggers import logger
+from prediction_market_agent_tooling.markets.agent_market import (
+    AgentMarket,
+    FilterBy,
+    SortBy,
+)
+from prediction_market_agent_tooling.markets.data_models import (
+    BetAmount,
+    Position,
+    ProbabilisticAnswer,
+    TokenAmount,
+    Trade,
+    TradeType,
+)
+from prediction_market_agent_tooling.markets.markets import MarketType
+from prediction_market_agent_tooling.markets.omen.omen import OmenAgentMarket
+from prediction_market_agent_tooling.markets.omen.omen_subgraph_handler import (
+    OmenSubgraphHandler,
+)
+from prediction_market_agent_tooling.tools.langfuse_ import (
+    get_langfuse_langchain_config,
+    observe,
+)
+
+from prediction_market_agent.agents.arbitrage_agent.data_models import (
+    CorrelatedMarketPair,
+    Correlation,
+)
+from prediction_market_agent.agents.arbitrage_agent.prompt import prompt_template
+from prediction_market_agent.db.pinecone_handler import PineconeHandler
+from prediction_market_agent.utils import APIKeys
+
+
+class DeployableArbitrageAgent(DeployableTraderAgent):
+    """Agent that places mirror bets on Omen for (quasi) risk-neutral profit."""
+
+    model = "gpt-4o"
+    # trade amount will be divided between correlated markets.
+    total_trade_amount = BetAmount(amount=0.1, currency=OmenAgentMarket.currency)
+
+    def run(self, market_type: MarketType) -> None:
+        if market_type != MarketType.OMEN:
+            raise RuntimeError(
+                "Can arbitrage only on Omen since related markets embeddings available only for Omen markets."
+            )
+        self.subgraph_handler = OmenSubgraphHandler()
+        self.pinecone_handler = PineconeHandler()
+        self.chain = self._build_chain()
+        self.pinecone_handler.update_markets()
+        super().run(market_type=market_type)
+
+    def get_markets(
+        self,
+        market_type: MarketType,
+        limit: int = MAX_AVAILABLE_MARKETS,
+        sort_by: SortBy = SortBy.CLOSING_SOONEST,
+        filter_by: FilterBy = FilterBy.OPEN,
+    ) -> t.Sequence[AgentMarket]:
+        return super().get_markets(
+            market_type=market_type,
+            limit=limit,
+            sort_by=SortBy.HIGHEST_LIQUIDITY,
+            # Fetching most liquid markets since more likely they will have related markets
+            filter_by=FilterBy.OPEN,
+        )
+
+    def answer_binary_market(self, market: AgentMarket) -> ProbabilisticAnswer | None:
+        return ProbabilisticAnswer(p_yes=Probability(0.5), confidence=1.0)
+
+    def _build_chain(self) -> RunnableSerializable[t.Any, t.Any]:
+        llm = ChatOpenAI(
+            temperature=0,
+            model=self.model,
+            api_key=APIKeys().openai_api_key_secretstr_v1,
+        )
+
+        parser = PydanticOutputParser(pydantic_object=Correlation)
+        prompt = PromptTemplate(
+            template=prompt_template,
+            input_variables=["main_market_question", "related_market_question"],
+            partial_variables={"format_instructions": parser.get_format_instructions()},
+        )
+
+        chain = prompt | llm | parser
+        return chain
+
+    @observe()
+    def calculate_correlation_between_markets(
+        self, market: AgentMarket, related_market: AgentMarket
+    ) -> Correlation:
+        correlation: Correlation = self.chain.invoke(
+            {
+                "main_market_question": market.question,
+                "related_market_question": related_market.question,
+            }
+        )
+        return correlation
+
+    @observe()
+    def get_correlated_markets(self, market: AgentMarket) -> list[CorrelatedMarketPair]:
+        # We try to find similar, open markets which point to the same outcome.
+        correlated_markets = []
+        related = self.pinecone_handler.find_nearest_questions_with_threshold(
+            limit=10, text=market.question
+        )
+
+        omen_markets = self.subgraph_handler.get_omen_binary_markets(
+            limit=len(related),
+            id_in=[i.market_address.lower() for i in related],
+            resolved=False,
+        )
+        omen_markets = [m for m in omen_markets if m.id != market.id]
+        # Note that negative correlation is hard - e.g. for the US presidential election, markets on each candidate are not seen as -100% correlated.
+        for related_market in omen_markets:
+            result: Correlation = self.chain.invoke(
+                {
+                    "main_market_question": market,
+                    "related_market_question": related_market,
+                },
+                config=get_langfuse_langchain_config(),
+            )
+            if result.near_perfect_correlation:
+                related_agent_market = OmenAgentMarket.from_data_model(related_market)
+                correlated_markets.append(
+                    CorrelatedMarketPair(
+                        main_market=market,
+                        related_market=related_agent_market,
+                    )
+                )
+        return correlated_markets
+
+    @observe()
+    def build_trades_for_correlated_markets(
+        self, pair: CorrelatedMarketPair
+    ) -> list[Trade]:
+        market_to_bet_yes, market_to_bet_no = pair.main_market, pair.related_market
+
+        # Split between main_market and related_market
+        amount_yes, amount_no = pair.split_bet_amount_between_yes_and_no(
+            self.total_trade_amount.amount
+        )
+        trades = [
+            Trade(
+                trade_type=TradeType.BUY,
+                outcome=True,
+                amount=TokenAmount(
+                    amount=amount_yes, currency=market_to_bet_yes.currency
+                ),
+            ),
+            Trade(
+                trade_type=TradeType.BUY,
+                outcome=False,
+                amount=TokenAmount(
+                    amount=amount_no, currency=market_to_bet_no.currency
+                ),
+            ),
+        ]
+        logger.info(f"Placing arbitrage trades {trades}")
+        return trades
+
+    @observe()
+    def build_trades(
+        self,
+        market: AgentMarket,
+        answer: ProbabilisticAnswer,
+        existing_position: Position | None,
+    ) -> list[Trade]:
+        trades = []
+        correlated_markets = self.get_correlated_markets(market=market)
+        for pair in correlated_markets:
+            if pair.potential_profit_per_bet_unit > 0:
+                trades_for_pair = self.build_trades_for_correlated_markets(pair)
+                trades.extend(trades_for_pair)
+
+        return trades

prediction_market_agent/agents/arbitrage_agent/prompt.py

@@ -0,0 +1,12 @@
+prompt_template = """Given two markets, MARKET 1 and MARKET 2, provide a boolean value that represents the correlation between these two markets' outcomes. Return True if the outcomes are perfectly or nearly perfectly correlated, meaning there is a high probability that both markets resolve to the same outcome. Return False if the correlation is weak or non-existent.
+Correlation can also be understood as the conditional probability that market 2 resolves to YES, given that market 1 resolved to YES.
+In addition to the boolean value, explain the reasoning behind your decision. 
+
+[MARKET 1]
+{main_market_question}
+
+[MARKET 2]
+{related_market_question}
+
+Follow the formatting instructions below for producing an output in the correct format.
+{format_instructions}"""

prediction_market_agent/agents/think_thoroughly_agent/deploy.py

@@ -30,7 +30,7 @@ def answer_binary_market(self, market: AgentMarket) -> ProbabilisticAnswer | Non
         )
 
     def before_process_markets(self, market_type: MarketType) -> None:
-        self.agent.update_markets()
+        self.agent.pinecone_handler.update_markets()
         super().before_process_markets(market_type=market_type)
 
 

prediction_market_agent/agents/think_thoroughly_agent/think_thoroughly_agent.py

@@ -1,4 +1,3 @@
-import datetime
 import typing as t
 from abc import ABC
 from uuid import UUID, uuid4
@@ -183,14 +182,6 @@ def _build_llm(model: str) -> BaseChatModel:
         )
         return llm
 
-    def update_markets(self) -> None:
-        """We use the agent's run to add embeddings of new markets that don't exist yet in the
-        vector DB."""
-        created_after = utcnow() - datetime.timedelta(days=7)
-        self.pinecone_handler.insert_all_omen_markets_if_not_exists(
-            created_after=created_after
-        )
-
     @observe()
     def get_required_conditions(self, question: str) -> Scenarios:
         researcher = self._get_researcher(self.model)

prediction_market_agent/db/pinecone_handler.py

@@ -1,4 +1,5 @@
 import base64
+import datetime
 import sys
 import typing as t
 from typing import Optional
@@ -13,7 +14,7 @@
 from prediction_market_agent_tooling.markets.omen.omen_subgraph_handler import (
     OmenSubgraphHandler,
 )
-from prediction_market_agent_tooling.tools.utils import DatetimeUTC
+from prediction_market_agent_tooling.tools.utils import DatetimeUTC, utcnow
 from tqdm import tqdm
 
 from prediction_market_agent.agents.think_thoroughly_agent.models import (
@@ -109,6 +110,12 @@ def deduplicate_markets(markets: list[OmenMarket]) -> list[OmenMarket]:
 
         return list(unique_market_titles.values())
 
+    def update_markets(self) -> None:
+        """We use the agent's run to add embeddings of new markets that don't exist yet in the
+        vector DB."""
+        created_after = utcnow() - datetime.timedelta(days=7)
+        self.insert_all_omen_markets_if_not_exists(created_after=created_after)
+
     def insert_all_omen_markets_if_not_exists(
         self, created_after: DatetimeUTC | None = None
     ) -> None:

prediction_market_agent/run_agent.py

@@ -12,6 +12,9 @@
 from prediction_market_agent_tooling.deploy.agent import DeployableAgent
 from prediction_market_agent_tooling.markets.markets import MarketType
 
+from prediction_market_agent.agents.arbitrage_agent.deploy import (
+    DeployableArbitrageAgent,
+)
 from prediction_market_agent.agents.coinflip_agent.deploy import DeployableCoinFlipAgent
 from prediction_market_agent.agents.known_outcome_agent.deploy import (
     DeployableKnownOutcomeAgent,
@@ -74,6 +77,7 @@ class RunnableAgent(str, Enum):
     social_media = "social_media"
     omen_cleaner = "omen_cleaner"
     ofv_challenger = "ofv_challenger"
+    arbitrage = "arbitrage"
 
 
 RUNNABLE_AGENTS: dict[RunnableAgent, type[DeployableAgent]] = {
@@ -98,6 +102,7 @@ class RunnableAgent(str, Enum):
     RunnableAgent.ofv_challenger: OFVChallengerAgent,
     RunnableAgent.prophet_o1preview: DeployablePredictionProphetGPTo1PreviewAgent,
     RunnableAgent.prophet_o1mini: DeployablePredictionProphetGPTo1MiniAgent,
+    RunnableAgent.arbitrage: DeployableArbitrageAgent,
 }
 
 APP = typer.Typer(pretty_exceptions_enable=False)